package main

import "C"
import (
	"context"
	"core/state"
	"errors"
	"github.com/metacubex/mihomo/constant/features"
	"github.com/metacubex/mihomo/hub/route"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"sync"
	"syscall"
	"time"

	"github.com/metacubex/mihomo/adapter"
	"github.com/metacubex/mihomo/adapter/inbound"
	"github.com/metacubex/mihomo/adapter/outboundgroup"
	"github.com/metacubex/mihomo/adapter/provider"
	"github.com/metacubex/mihomo/common/batch"
	"github.com/metacubex/mihomo/component/dialer"
	"github.com/metacubex/mihomo/component/resolver"
	"github.com/metacubex/mihomo/config"
	"github.com/metacubex/mihomo/constant"
	cp "github.com/metacubex/mihomo/constant/provider"
	"github.com/metacubex/mihomo/hub"
	"github.com/metacubex/mihomo/hub/executor"
	"github.com/metacubex/mihomo/listener"
	"github.com/metacubex/mihomo/log"
	rp "github.com/metacubex/mihomo/rules/provider"
	"github.com/metacubex/mihomo/tunnel"
)

type ConfigExtendedParams struct {
	IsPatch      bool              `json:"is-patch"`
	IsCompatible bool              `json:"is-compatible"`
	SelectedMap  map[string]string `json:"selected-map"`
	TestURL      *string           `json:"test-url"`
	OverrideDns  bool              `json:"override-dns"`
}

type GenerateConfigParams struct {
	ProfileId string               `json:"profile-id"`
	Config    config.RawConfig     `json:"config" `
	Params    ConfigExtendedParams `json:"params"`
}

type ChangeProxyParams struct {
	GroupName *string `json:"group-name"`
	ProxyName *string `json:"proxy-name"`
}

type TestDelayParams struct {
	ProxyName string `json:"proxy-name"`
	Timeout   int64  `json:"timeout"`
}

type ProcessMapItem struct {
	Id    int64  `json:"id"`
	Value string `json:"value"`
}

type ExternalProvider struct {
	Name        string    `json:"name"`
	Type        string    `json:"type"`
	VehicleType string    `json:"vehicle-type"`
	Count       int       `json:"count"`
	Path        string    `json:"path"`
	UpdateAt    time.Time `json:"update-at"`
}

type ExternalProviders []ExternalProvider

func (a ExternalProviders) Len() int           { return len(a) }
func (a ExternalProviders) Less(i, j int) bool { return a[i].Name < a[j].Name }
func (a ExternalProviders) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

var b, _ = batch.New[bool](context.Background(), batch.WithConcurrencyNum[bool](50))

func restartExecutable(execPath string) {
	var err error
	executor.Shutdown()
	if runtime.GOOS == "windows" {
		cmd := exec.Command(execPath, os.Args[1:]...)
		log.Infoln("restarting: %q %q", execPath, os.Args[1:])
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		err = cmd.Start()
		if err != nil {
			log.Fatalln("restarting: %s", err)
		}

		os.Exit(0)
	}

	log.Infoln("restarting: %q %q", execPath, os.Args[1:])
	err = syscall.Exec(execPath, os.Args, os.Environ())
	if err != nil {
		log.Fatalln("restarting: %s", err)
	}
}

func readFile(path string) ([]byte, error) {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return nil, err
	}
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}

	return data, err
}

func removeFile(path string) error {
	absPath, err := filepath.Abs(path)
	if err != nil {
		return err
	}
	err = os.Remove(absPath)
	if err != nil {
		return err
	}

	return nil
}

func getProfilePath(id string) string {
	return filepath.Join(constant.Path.HomeDir(), "profiles", id+".yaml")
}

func getProfileProvidersPath(id string) string {
	return filepath.Join(constant.Path.HomeDir(), "providers", id)
}

func getRawConfigWithId(id string) *config.RawConfig {
	path := getProfilePath(id)
	bytes, err := readFile(path)
	if err != nil {
		log.Errorln("profile is not exist")
		return config.DefaultRawConfig()
	}
	prof, err := config.UnmarshalRawConfig(bytes)
	if err != nil {
		log.Errorln("unmarshalRawConfig error %v", err)
		return config.DefaultRawConfig()
	}
	for _, mapping := range prof.ProxyProvider {
		value, exist := mapping["path"].(string)
		if !exist {
			continue
		}
		mapping["path"] = filepath.Join(getProfileProvidersPath(id), value)
	}
	for _, mapping := range prof.RuleProvider {
		value, exist := mapping["path"].(string)
		if !exist {
			continue
		}
		mapping["path"] = filepath.Join(getProfileProvidersPath(id), value)
	}
	return prof
}

func getExternalProvidersRaw() map[string]cp.Provider {
	eps := make(map[string]cp.Provider)
	for n, p := range tunnel.Providers() {
		if p.VehicleType() != cp.Compatible {
			eps[n] = p
		}
	}
	for n, p := range tunnel.RuleProviders() {
		if p.VehicleType() != cp.Compatible {
			eps[n] = p
		}
	}
	return eps
}

func toExternalProvider(p cp.Provider) (*ExternalProvider, error) {
	switch p.(type) {
	case *provider.ProxySetProvider:
		psp := p.(*provider.ProxySetProvider)
		return &ExternalProvider{
			Name:        psp.Name(),
			Type:        psp.Type().String(),
			VehicleType: psp.VehicleType().String(),
			Count:       psp.Count(),
			Path:        psp.Vehicle().Path(),
			UpdateAt:    psp.UpdatedAt(),
		}, nil
	case *rp.RuleSetProvider:
		rsp := p.(*rp.RuleSetProvider)
		return &ExternalProvider{
			Name:        rsp.Name(),
			Type:        rsp.Type().String(),
			VehicleType: rsp.VehicleType().String(),
			Count:       rsp.Count(),
			Path:        rsp.Vehicle().Path(),
			UpdateAt:    rsp.UpdatedAt(),
		}, nil
	default:
		return nil, errors.New("not external provider")
	}
}

func sideUpdateExternalProvider(p cp.Provider, bytes []byte) error {
	switch p.(type) {
	case *provider.ProxySetProvider:
		psp := p.(*provider.ProxySetProvider)
		elm, same, err := psp.SideUpdate(bytes)
		if err == nil && !same {
			psp.OnUpdate(elm)
		}
		return nil
	case rp.RuleSetProvider:
		rsp := p.(*rp.RuleSetProvider)
		elm, same, err := rsp.SideUpdate(bytes)
		if err == nil && !same {
			rsp.OnUpdate(elm)
		}
		return nil
	default:
		return errors.New("not external provider")
	}
}

func decorationConfig(profileId string, cfg config.RawConfig) *config.RawConfig {
	prof := getRawConfigWithId(profileId)
	overwriteConfig(prof, cfg)
	return prof
}

//func Reduce[T any, U any](s []T, initVal U, f func(U, T) U) U {
//	for _, v := range s {
//		initVal = f(initVal, v)
//	}
//	return initVal
//}
//
//func Map[T, U any](slice []T, fn func(T) U) []U {
//	result := make([]U, len(slice))
//	for i, v := range slice {
//		result[i] = fn(v)
//	}
//	return result
//}
//
//func replaceFromMap(s string, m map[string]string) string {
//	for k, v := range m {
//		s = strings.ReplaceAll(s, k, v)
//	}
//	return s
//}
//
//func removeDuplicateFromSlice[T any](slice []T) []T {
//	result := make([]T, 0)
//	seen := make(map[any]struct{})
//	for _, value := range slice {
//		if _, ok := seen[value]; !ok {
//			result = append(result, value)
//			seen[value] = struct{}{}
//		}
//	}
//	return result
//}

//func generateProxyGroupAndRule(proxyGroup *[]map[string]any, rule *[]string) {
//	var replacements = map[string]string{}
//	var selectArr []map[string]any
//	var urlTestArr []map[string]any
//	var fallbackArr []map[string]any
//	for _, group := range *proxyGroup {
//		switch group["type"] {
//		case "select":
//			selectArr = append(selectArr, group)
//			replacements[group["name"].(string)] = "Proxy"
//			break
//		case "url-test":
//			urlTestArr = append(urlTestArr, group)
//			replacements[group["name"].(string)] = "Auto"
//			break
//		case "fallback":
//			fallbackArr = append(fallbackArr, group)
//			replacements[group["name"].(string)] = "Fallback"
//			break
//		default:
//			break
//		}
//	}
//
//	ProxyProxies := Reduce(selectArr, []string{}, func(res []string, cur map[string]any) []string {
//		if cur["proxies"] == nil {
//			return res
//		}
//		for _, proxyName := range cur["proxies"].([]interface{}) {
//			if str, ok := proxyName.(string); ok {
//				str = replaceFromMap(str, replacements)
//				if str != "Proxy" {
//					res = append(res, str)
//				}
//			}
//		}
//		return res
//	})
//
//	ProxyProxies = removeDuplicateFromSlice(ProxyProxies)
//
//	AutoProxies := Reduce(urlTestArr, []string{}, func(res []string, cur map[string]any) []string {
//		if cur["proxies"] == nil {
//			return res
//		}
//		for _, proxyName := range cur["proxies"].([]interface{}) {
//			if str, ok := proxyName.(string); ok {
//				str = replaceFromMap(str, replacements)
//				if str != "Auto" {
//					res = append(res, str)
//				}
//			}
//		}
//		return res
//	})
//
//	AutoProxies = removeDuplicateFromSlice(AutoProxies)
//
//	FallbackProxies := Reduce(fallbackArr, []string{}, func(res []string, cur map[string]any) []string {
//		if cur["proxies"] == nil {
//			return res
//		}
//		for _, proxyName := range cur["proxies"].([]interface{}) {
//			if str, ok := proxyName.(string); ok {
//				str = replaceFromMap(str, replacements)
//				if str != "Fallback" {
//					res = append(res, str)
//				}
//			}
//		}
//		return res
//	})
//
//	FallbackProxies = removeDuplicateFromSlice(FallbackProxies)
//
//	var computedProxyGroup []map[string]any
//
//	if len(ProxyProxies) > 0 {
//		computedProxyGroup = append(computedProxyGroup,
//			map[string]any{
//				"name":    "Proxy",
//				"type":    "select",
//				"proxies": ProxyProxies,
//			})
//	}
//
//	if len(AutoProxies) > 0 {
//		computedProxyGroup = append(computedProxyGroup,
//			map[string]any{
//				"name":    "Auto",
//				"type":    "url-test",
//				"proxies": AutoProxies,
//			})
//	}
//
//	if len(FallbackProxies) > 0 {
//		computedProxyGroup = append(computedProxyGroup,
//			map[string]any{
//				"name":    "Fallback",
//				"type":    "fallback",
//				"proxies": FallbackProxies,
//			})
//	}
//
//	computedRule := Map(*rule, func(value string) string {
//		return replaceFromMap(value, replacements)
//	})
//
//	*proxyGroup = computedProxyGroup
//	*rule = computedRule
//}

func genHosts(hosts, patchHosts map[string]any) {
	for k, v := range patchHosts {
		hosts[k] = v
	}
}

func overwriteConfig(targetConfig *config.RawConfig, patchConfig config.RawConfig) {
	targetConfig.ExternalController = patchConfig.ExternalController
	targetConfig.ExternalUI = ""
	targetConfig.Interface = ""
	targetConfig.ExternalUIURL = ""
	targetConfig.TCPConcurrent = patchConfig.TCPConcurrent
	targetConfig.UnifiedDelay = patchConfig.UnifiedDelay
	targetConfig.IPv6 = patchConfig.IPv6
	targetConfig.LogLevel = patchConfig.LogLevel
	targetConfig.Port = 0
	targetConfig.SocksPort = 0
	targetConfig.KeepAliveInterval = patchConfig.KeepAliveInterval
	targetConfig.MixedPort = patchConfig.MixedPort
	targetConfig.FindProcessMode = patchConfig.FindProcessMode
	targetConfig.AllowLan = patchConfig.AllowLan
	targetConfig.Mode = patchConfig.Mode
	targetConfig.Tun.Enable = patchConfig.Tun.Enable
	targetConfig.Tun.Device = patchConfig.Tun.Device
	targetConfig.Tun.DNSHijack = patchConfig.Tun.DNSHijack
	targetConfig.Tun.Stack = patchConfig.Tun.Stack
	targetConfig.GeodataLoader = patchConfig.GeodataLoader
	targetConfig.Profile.StoreSelected = false
	targetConfig.GeoXUrl = patchConfig.GeoXUrl
	targetConfig.GlobalUA = patchConfig.GlobalUA
	if configParams.TestURL != nil {
		constant.DefaultTestURL = *configParams.TestURL
	}
	for idx := range targetConfig.ProxyGroup {
		targetConfig.ProxyGroup[idx]["url"] = ""
	}
	genHosts(targetConfig.Hosts, patchConfig.Hosts)
	if configParams.OverrideDns {
		targetConfig.DNS = patchConfig.DNS
	} else {
		if targetConfig.DNS.Enable == false {
			targetConfig.DNS.Enable = true
		}
	}
	//if runtime.GOOS == "android" {
	//	targetConfig.DNS.NameServer = append(targetConfig.DNS.NameServer, "dhcp://"+dns.SystemDNSPlaceholder)
	//} else if runtime.GOOS == "windows" {
	//	targetConfig.DNS.NameServer = append(targetConfig.DNS.NameServer, dns.SystemDNSPlaceholder)
	//}
	//if configParams.IsCompatible == false {
	//	targetConfig.ProxyProvider = make(map[string]map[string]any)
	//	targetConfig.RuleProvider = make(map[string]map[string]any)
	//	generateProxyGroupAndRule(&targetConfig.ProxyGroup, &targetConfig.Rule)
	//}
}

func patchConfig(general *config.General, controller *config.Controller) {
	log.Infoln("[Apply] patch")
	route.ReStartServer(controller.ExternalController)
	tunnel.SetSniffing(general.Sniffing)
	tunnel.SetFindProcessMode(general.FindProcessMode)
	dialer.SetTcpConcurrent(general.TCPConcurrent)
	dialer.DefaultInterface.Store(general.Interface)
	adapter.UnifiedDelay.Store(general.UnifiedDelay)
	tunnel.SetMode(general.Mode)
	log.SetLevel(general.LogLevel)
	resolver.DisableIPv6 = !general.IPv6
}

var isRunning = false

var runLock sync.Mutex

func updateListeners(general *config.General, listeners map[string]constant.InboundListener) {
	if !isRunning {
		return
	}
	runLock.Lock()
	defer runLock.Unlock()
	listener.PatchInboundListeners(listeners, tunnel.Tunnel, true)
	listener.SetAllowLan(general.AllowLan)
	inbound.SetSkipAuthPrefixes(general.SkipAuthPrefixes)
	inbound.SetAllowedIPs(general.LanAllowedIPs)
	inbound.SetDisAllowedIPs(general.LanDisAllowedIPs)
	listener.SetBindAddress(general.BindAddress)
	listener.ReCreateHTTP(general.Port, tunnel.Tunnel)
	listener.ReCreateSocks(general.SocksPort, tunnel.Tunnel)
	listener.ReCreateRedir(general.RedirPort, tunnel.Tunnel)
	listener.ReCreateTProxy(general.TProxyPort, tunnel.Tunnel)
	listener.ReCreateMixed(general.MixedPort, tunnel.Tunnel)
	listener.ReCreateShadowSocks(general.ShadowSocksConfig, tunnel.Tunnel)
	listener.ReCreateVmess(general.VmessConfig, tunnel.Tunnel)
	listener.ReCreateTuic(general.TuicServer, tunnel.Tunnel)
	if !features.Android {
		listener.ReCreateTun(general.Tun, tunnel.Tunnel)
	}
}

func stopListeners() {
	listener.StopListener()
}

func hcCompatibleProvider(proxyProviders map[string]cp.ProxyProvider) {
	wg := sync.WaitGroup{}
	ch := make(chan struct{}, math.MaxInt)
	for _, proxyProvider := range proxyProviders {
		proxyProvider := proxyProvider
		if proxyProvider.VehicleType() == cp.Compatible {
			log.Infoln("Start initial Compatible provider %s", proxyProvider.Name())
			wg.Add(1)
			ch <- struct{}{}
			go func() {
				defer func() { <-ch; wg.Done() }()
				if err := proxyProvider.Initial(); err != nil {
					log.Errorln("initial Compatible provider %s error: %v", proxyProvider.Name(), err)
				}
			}()
		}

	}

}

func patchSelectGroup() {
	mapping := configParams.SelectedMap
	if mapping == nil {
		return
	}
	for name, proxy := range tunnel.ProxiesWithProviders() {
		outbound, ok := proxy.(*adapter.Proxy)
		if !ok {
			continue
		}

		selector, ok := outbound.ProxyAdapter.(outboundgroup.SelectAble)
		if !ok {
			continue
		}

		selected, exist := mapping[name]
		if !exist {
			continue
		}

		selector.ForceSet(selected)
	}
}

func applyConfig() error {
	cfg, err := config.ParseRawConfig(state.CurrentRawConfig)
	if err != nil {
		cfg, _ = config.ParseRawConfig(config.DefaultRawConfig())
	}
	if configParams.IsPatch {
		patchConfig(cfg.General, cfg.Controller)
	} else {
		closeConnections()
		runtime.GC()
		hub.UltraApplyConfig(cfg)
		patchSelectGroup()
	}
	updateListeners(cfg.General, cfg.Listeners)
	if isRunning {
		hcCompatibleProvider(cfg.Providers)
	}
	externalProviders = getExternalProvidersRaw()
	return err
}