package apps

import (
	"strings"
	"sync"

	"github.com/iwind/TeaGo/maps"
)

var appStore = struct {
	sync.RWMutex
	data []maps.Map
}{
	data: defaultMockApps(),
}

func defaultMockApps() []maps.Map {
	return []maps.Map{
		{
			"id":            int64(1),
			"name":          "\u4e3b\u7ad9\u79fb\u52a8\u4e1a\u52a1",
			"appId":         "ab12xc34s2",
			"clusterId":     int64(1),
			"domainCount":   3,
			"isOn":          true,
			"authStatus":    "enabled",
			"ecsMode":       "auto",
			"pinningMode":   "report",
			"sanMode":       "strict",
			"riskLevel":     "medium",
			"riskSummary":   "Pinning \u5904\u4e8e\u89c2\u5bdf\u6a21\u5f0f",
			"secretVersion": "v2026.02.20",
		},
		{
			"id":            int64(2),
			"name":          "\u89c6\u9891\u7f51\u5173\u4e1a\u52a1",
			"appId":         "vd8992ksm1",
			"clusterId":     int64(2),
			"domainCount":   1,
			"isOn":          true,
			"authStatus":    "enabled",
			"ecsMode":       "custom",
			"pinningMode":   "enforce",
			"sanMode":       "strict",
			"riskLevel":     "low",
			"riskSummary":   "\u5df2\u542f\u7528\u5f3a\u6821\u9a8c",
			"secretVersion": "v2026.02.18",
		},
		{
			"id":            int64(3),
			"name":          "\u6d77\u5916\u7070\u5ea6\u6d4b\u8bd5",
			"appId":         "ov7711hkq9",
			"clusterId":     int64(1),
			"domainCount":   2,
			"isOn":          false,
			"authStatus":    "disabled",
			"ecsMode":       "off",
			"pinningMode":   "off",
			"sanMode":       "report",
			"riskLevel":     "high",
			"riskSummary":   "\u5e94\u7528\u5173\u95ed\u4e14\u8bc1\u4e66\u7b56\u7565\u504f\u5f31",
			"secretVersion": "v2026.01.30",
		},
	}
}

func cloneMap(src maps.Map) maps.Map {
	dst := maps.Map{}
	for k, v := range src {
		dst[k] = v
	}
	return dst
}

func cloneApps(apps []maps.Map) []maps.Map {
	result := make([]maps.Map, 0, len(apps))
	for _, app := range apps {
		result = append(result, cloneMap(app))
	}
	return result
}

func mockApps() []maps.Map {
	appStore.RLock()
	defer appStore.RUnlock()
	return cloneApps(appStore.data)
}

func deleteApp(appID int64) bool {
	if appID <= 0 {
		return false
	}

	appStore.Lock()
	defer appStore.Unlock()

	found := false
	filtered := make([]maps.Map, 0, len(appStore.data))
	for _, app := range appStore.data {
		if app.GetInt64("id") == appID {
			found = true
			continue
		}
		filtered = append(filtered, app)
	}
	if found {
		appStore.data = filtered
	}
	return found
}

func filterApps(keyword string, riskLevel string, ecsMode string, pinningMode string) []maps.Map {
	all := mockApps()
	if len(keyword) == 0 && len(riskLevel) == 0 && len(ecsMode) == 0 && len(pinningMode) == 0 {
		return all
	}

	keyword = strings.ToLower(strings.TrimSpace(keyword))
	result := make([]maps.Map, 0)
	for _, app := range all {
		if len(keyword) > 0 {
			name := strings.ToLower(app.GetString("name"))
			appID := strings.ToLower(app.GetString("appId"))
			if !strings.Contains(name, keyword) && !strings.Contains(appID, keyword) {
				continue
			}
		}
		if len(riskLevel) > 0 && app.GetString("riskLevel") != riskLevel {
			continue
		}
		if len(ecsMode) > 0 && app.GetString("ecsMode") != ecsMode {
			continue
		}
		if len(pinningMode) > 0 && app.GetString("pinningMode") != pinningMode {
			continue
		}
		result = append(result, app)
	}

	return result
}

func pickApp(appID int64) maps.Map {
	apps := mockApps()
	if len(apps) == 0 {
		return maps.Map{
			"id":        int64(0),
			"name":      "",
			"appId":     "",
			"clusterId": int64(0),
		}
	}

	if appID <= 0 {
		return apps[0]
	}
	for _, app := range apps {
		if app.GetInt64("id") == appID {
			return app
		}
	}
	return apps[0]
}

func mockDomains(appID int64) []maps.Map {
	_ = appID
	return []maps.Map{
		{
			"id":   int64(101),
			"name": "api.business.com",
		},
		{
			"id":   int64(102),
			"name": "payment.business.com",
		},
	}
}

func pickDomain(domainID int64) maps.Map {
	domains := mockDomains(0)
	if domainID <= 0 {
		return domains[0]
	}
	for _, domain := range domains {
		if domain.GetInt64("id") == domainID {
			return domain
		}
	}
	return domains[0]
}