package main

import (
	"fmt"
	"reflect"
	"sort"
	"strings"
)

/* COMPARISON FUNCTIONS */

func compareOrigins(old, new []originItem) string {
	oldMap := make(map[string]originItem)
	newMap := make(map[string]originItem)

	for _, o := range old {
		oldMap[o.IP] = o
	}
	for _, o := range new {
		newMap[o.IP] = o
	}

	var added []originItem
	var removed []originItem
	var modified []string

	for ip, newOrigin := range newMap {
		if oldOrigin, exists := oldMap[ip]; !exists {
			added = append(added, newOrigin)
		} else {
			if oldOrigin.Mode != newOrigin.Mode || oldOrigin.Weight != newOrigin.Weight {
				modified = append(modified,
					fmt.Sprintf("  IP: %s\n    Было: mode=%s, weight=%d\n    Стало: mode=%s, weight=%d",
						ip, oldOrigin.Mode, oldOrigin.Weight, newOrigin.Mode, newOrigin.Weight))
			}
		}
	}

	for ip, oldOrigin := range oldMap {
		if _, exists := newMap[ip]; !exists {
			removed = append(removed, oldOrigin)
		}
	}

	if len(added) == 0 && len(removed) == 0 && len(modified) == 0 {
		return ""
	}

	var result strings.Builder
	result.WriteString("<b>📡 Origins:</b>")

	if len(added) > 0 {
		result.WriteString("\n\n<b>✅ Добавлено:</b>\n")
		for _, origin := range added {
			result.WriteString(fmt.Sprintf("  IP: %s\n    mode=%s, weight=%d\n",
				origin.IP, origin.Mode, origin.Weight))
		}
	}

	if len(removed) > 0 {
		result.WriteString("\n<b>❌ Удалено:</b>\n")
		for _, origin := range removed {
			result.WriteString(fmt.Sprintf("  IP: %s\n    mode=%s, weight=%d\n",
				origin.IP, origin.Mode, origin.Weight))
		}
	}

	if len(modified) > 0 {
		result.WriteString("\n<b>🔄 Изменено:</b>\n")
		result.WriteString(strings.Join(modified, "\n"))
	}

	// Добавляем текущее состояние после всех изменений
	result.WriteString("\n\n<b>📋 Текущее состояние:</b>\n")

	// Сортируем для красивого вывода
	var sortedOrigins []originItem
	for _, origin := range newMap {
		sortedOrigins = append(sortedOrigins, origin)
	}
	sort.Slice(sortedOrigins, func(i, j int) bool {
		return sortedOrigins[i].IP < sortedOrigins[j].IP
	})

	for _, origin := range sortedOrigins {
		result.WriteString(fmt.Sprintf("  IP: %s\n    mode=%s, weight=%d\n",
			origin.IP, origin.Mode, origin.Weight))
	}

	return result.String()
}

func compareAliases(old, new []string) (string, bool) {
	oldSorted := make([]string, len(old))
	newSorted := make([]string, len(new))
	copy(oldSorted, old)
	copy(newSorted, new)
	sort.Strings(oldSorted)
	sort.Strings(newSorted)

	if reflect.DeepEqual(oldSorted, newSorted) {
		return "", false
	}

	oldMap := make(map[string]bool)
	newMap := make(map[string]bool)

	for _, a := range old {
		oldMap[a] = true
	}
	for _, a := range new {
		newMap[a] = true
	}

	var added []string
	var removed []string

	for _, a := range new {
		if !oldMap[a] {
			added = append(added, a)
		}
	}

	for _, a := range old {
		if !newMap[a] {
			removed = append(removed, a)
		}
	}

	var result strings.Builder
	result.WriteString("<b>🌐 Aliases:</b>")

	if len(added) > 0 {
		result.WriteString("\n\n<b>✅ Добавлено:</b>\n\n")
		for _, alias := range added {
			result.WriteString(alias + "\n")
		}
	}

	if len(removed) > 0 {
		result.WriteString("\n<b>❌ Удалено:</b>\n\n")
		for _, alias := range removed {
			result.WriteString(alias + "\n")
		}
	}

	return result.String(), true
}