package main

import (
	"errors"
	"fmt"
	"strings"
)

var startPattern = "DNSHelper <<-> START CONFIG"
var endPattern = "DNSHelper <->> END CONFIG"

func extractLinesToEdit(data *workingData) error {
	startIndex := 0
	endIndex := 0
	for i, line := range data.DefaultContent {
		if strings.Contains(line, startPattern) {
			startIndex = i
			continue
		}
		if strings.Contains(line, endPattern) {
			endIndex = i
			break
		}
	}
	var fileModified bool
	var fileCorrupted bool
	switch {
	case startIndex == 0 && endIndex == 0:
		fileModified = false
		fileCorrupted = false
	case startIndex > 0 && endIndex > startIndex:
		fileModified = true
		fileCorrupted = false
	default:
		fileModified = true
		fileCorrupted = true
	}

	if fileCorrupted == true {
		return errors.New("content has been corrupted")
	}

	if fileModified == true {
		data.PrefixContent = data.DefaultContent[:startIndex]
		data.PostfixContent = data.DefaultContent[endIndex+1:]
		data.ExistingContent = data.DefaultContent[startIndex+1 : endIndex]
	} else {
		data.PrefixContent = data.DefaultContent
		data.PostfixContent = make([]string, 0)
		data.ExistingContent = make([]string, 0)
	}
	data.NewContent = make([]string, 0)
	//fmt.Println("PrefixContent:")
	//for _, line := range data.PrefixContent {
	//	fmt.Println(line)
	//}
	//fmt.Println("ExistingContent:")
	//for _, line := range data.ExistingContent {
	//	fmt.Println(line)
	//}
	//fmt.Println("PostfixContent:")
	//for _, line := range data.PostfixContent {
	//	fmt.Println(line)
	//}
	return nil
}

func removeHostsFromExistingContent(data *workingData) {
	var updatedContent []string
	for _, host := range data.Hosts {
		for _, line := range data.ExistingContent {
			if !strings.Contains(line, host) {
				updatedContent = append(updatedContent, line)
			}
		}
	}
	data.NewContent = updatedContent
}

func addHostsToWorkingData(data *workingData, hosts *string) {
	hostToAddList := strings.Split(*hosts, ",")
	var newHosts []string
	for _, host := range hostToAddList {
		newHosts = append(newHosts, host)
	}
	data.Hosts = newHosts
}

func addResolversToWorkingData(data *workingData, resolvers *string) {
	resolverToAddList := strings.Split(*resolvers, ",")
	var newResolvers []string
	for _, resolver := range resolverToAddList {
		newResolvers = append(newResolvers, resolver)
	}
	data.Resolvers = newResolvers
}

func addNameToIPMappingsToNewContent(data *workingData) {
	for _, host := range data.Hosts {
		for _, resolver := range data.Resolvers {
			ips := lookupIP(host, resolver)
			if len(ips) > 0 {
				for _, ip := range ips {
					data.NewContent = append(data.NewContent, fmt.Sprintf("%s\t%s", ip, host))
				}
			}
		}
	}
}

func slicesEqual(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

func dedupeSlice(slice []string) []string {
	newSlice := make([]string, 0, len(slice))
	seen := make(map[string]bool)
	for _, value := range slice {
		if !seen[value] {
			seen[value] = true
			newSlice = append(newSlice, value)
		}
	}
	return newSlice
}