package common

import (
	"encoding/json"
	"fmt"
	stdhtml "html"
	"io"
	"net/http"
	"net/url"
	"path"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
)

const nanokaHSRStaticBaseURL = "https://static.nanoka.cc/hsr"

var nanokaVersionPattern = regexp.MustCompile(`^[0-9]+\.[0-9]+(?:\.[0-9]+)?$`)
var nanokaMarkupTagPattern = regexp.MustCompile(`<[^>]*>`)

type NanokaMonsterMetadata struct {
	Version  string
	Monsters map[uint32]MonsterSettingsMonsterMetadata
	Groups   map[uint32]map[string]string
}

type nanokaLocalizedRecord struct {
	English   string   `json:"en"`
	Chinese   string   `json:"zh"`
	Japanese  string   `json:"ja"`
	Korean    string   `json:"ko"`
	Icon      string   `json:"icon"`
	ImagePath string   `json:"image_path"`
	Child     []uint32 `json:"child"`
}

type nanokaMetadataCacheEntry struct {
	metadata NanokaMonsterMetadata
	fetched  time.Time
}

var nanokaMetadataCache = struct {
	sync.Mutex
	entries map[string]nanokaMetadataCacheEntry
}{entries: map[string]nanokaMetadataCacheEntry{}}

// LoadNanokaMonsterMetadata refreshes localized names and monster artwork for
// the exact Client version configured by the server. It never falls forward to
// Nanoka's latest version, which could disagree with the installed resources.
func LoadNanokaMonsterMetadata(clientVersion string) (NanokaMonsterMetadata, error) {
	version := strings.TrimSpace(clientVersion)
	if !nanokaVersionPattern.MatchString(version) {
		return NanokaMonsterMetadata{}, fmt.Errorf("invalid Client version for Nanoka metadata: %q", clientVersion)
	}

	nanokaMetadataCache.Lock()
	defer nanokaMetadataCache.Unlock()
	if cached, ok := nanokaMetadataCache.entries[version]; ok && time.Since(cached.fetched) < time.Hour {
		return cached.metadata, nil
	}

	metadata, err := fetchNanokaMonsterMetadata(version)
	if err != nil {
		if cached, ok := nanokaMetadataCache.entries[version]; ok {
			return cached.metadata, nil
		}
		return NanokaMonsterMetadata{}, err
	}
	nanokaMetadataCache.entries[version] = nanokaMetadataCacheEntry{metadata: metadata, fetched: time.Now()}
	return metadata, nil
}

func fetchNanokaMonsterMetadata(version string) (NanokaMonsterMetadata, error) {
	versionPath := url.PathEscape(version)
	baseURL := nanokaHSRStaticBaseURL + "/" + versionPath + "/"
	type result struct {
		endpoint string
		rows     map[string]json.RawMessage
		err      error
	}
	endpoints := []string{"monster.json", "maze.json", "maze_extra.json", "maze_peak.json"}
	results := make(chan result, len(endpoints))
	client := &http.Client{Timeout: 8 * time.Second}
	for _, endpoint := range endpoints {
		go func(endpoint string) {
			rows, err := fetchNanokaRows(client, baseURL+endpoint)
			results <- result{endpoint: endpoint, rows: rows, err: err}
		}(endpoint)
	}

	metadata := NanokaMonsterMetadata{
		Version:  version,
		Monsters: map[uint32]MonsterSettingsMonsterMetadata{},
		Groups:   map[uint32]map[string]string{},
	}
	var monsterErr error
	for range endpoints {
		res := <-results
		if res.err != nil {
			if res.endpoint == "monster.json" {
				monsterErr = res.err
			}
			continue
		}
		switch res.endpoint {
		case "monster.json":
			for rawID, raw := range res.rows {
				var record nanokaLocalizedRecord
				if err := json.Unmarshal(raw, &record); err != nil {
					continue
				}
				id, err := parsePositiveUint32(rawID)
				if err != nil {
					continue
				}
				names := nanokaLocalizedNames(record)
				iconURL := nanokaMonsterIconURL(record.Icon)
				if iconURL == "" {
					iconURL = nanokaMonsterIconURL(record.ImagePath)
				}
				if len(names) > 0 || iconURL != "" {
					metadata.Monsters[id] = MonsterSettingsMonsterMetadata{Names: names, IconURL: iconURL}
					for _, childID := range record.Child {
						if childID == 0 {
							continue
						}
						if _, exists := metadata.Monsters[childID]; !exists {
							metadata.Monsters[childID] = MonsterSettingsMonsterMetadata{Names: names, IconURL: iconURL}
						}
					}
				}
			}
		case "maze.json", "maze_extra.json", "maze_peak.json":
			for rawID, raw := range res.rows {
				id, err := parsePositiveUint32(rawID)
				if err != nil {
					continue
				}
				var record nanokaLocalizedRecord
				if err := json.Unmarshal(raw, &record); err != nil {
					continue
				}
				names := nanokaLocalizedNames(record)
				if len(names) > 0 {
					metadata.Groups[id] = names
				}
			}
		}
	}
	if monsterErr != nil {
		return NanokaMonsterMetadata{}, fmt.Errorf("read Nanoka monster data for Client %s: %w", version, monsterErr)
	}
	if len(metadata.Monsters) == 0 {
		return NanokaMonsterMetadata{}, fmt.Errorf("Nanoka returned no monster metadata for Client %s", version)
	}
	return metadata, nil
}

func fetchNanokaRows(client *http.Client, endpointURL string) (map[string]json.RawMessage, error) {
	request, err := http.NewRequest(http.MethodGet, endpointURL, nil)
	if err != nil {
		return nil, err
	}
	request.Header.Set("Accept", "application/json")
	response, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		_, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 4096))
		return nil, fmt.Errorf("Nanoka returned HTTP %d for %s", response.StatusCode, path.Base(endpointURL))
	}
	var rows map[string]json.RawMessage
	if err := json.NewDecoder(io.LimitReader(response.Body, 32<<20)).Decode(&rows); err != nil {
		return nil, fmt.Errorf("decode Nanoka %s: %w", path.Base(endpointURL), err)
	}
	return rows, nil
}

func nanokaLocalizedNames(record nanokaLocalizedRecord) map[string]string {
	names := map[string]string{}
	for locale, name := range map[string]string{
		"en": record.English, "zh": record.Chinese, "ja": record.Japanese, "ko": record.Korean,
	} {
		name = nanokaDisplayName(name)
		if name != "" {
			names[locale] = name
		}
	}
	return names
}

func nanokaDisplayName(value string) string {
	value = stdhtml.UnescapeString(value)
	value = nanokaMarkupTagPattern.ReplaceAllString(value, " ")
	return strings.Join(strings.Fields(value), " ")
}

func nanokaMonsterIconURL(iconPath string) string {
	iconPath = strings.ReplaceAll(strings.TrimSpace(iconPath), `\`, "/")
	if !strings.Contains(iconPath, "/MonsterFigure/") {
		return ""
	}
	filename := path.Base(iconPath)
	if !strings.HasPrefix(filename, "Monster_") || !strings.HasSuffix(strings.ToLower(filename), ".png") {
		return ""
	}
	filename = strings.TrimSuffix(filename, path.Ext(filename)) + ".webp"
	return "https://static.nanoka.cc/assets/hsr/monsterfigure/" + url.PathEscape(filename)
}

func (catalog *MonsterSettingsCatalog) ApplyNanokaMonsterMetadata(metadata NanokaMonsterMetadata) {
	if catalog == nil || metadata.Version == "" {
		return
	}
	catalog.Monsters = metadata.Monsters
	allIDs := make(map[uint32]struct{}, len(catalog.MonsterIDs)+len(metadata.Monsters))
	for _, id := range catalog.MonsterIDs {
		allIDs[id] = struct{}{}
	}
	for id := range metadata.Monsters {
		allIDs[id] = struct{}{}
	}
	catalog.MonsterIDs = catalog.MonsterIDs[:0]
	for id := range allIDs {
		catalog.MonsterIDs = append(catalog.MonsterIDs, id)
	}
	sort.Slice(catalog.MonsterIDs, func(i, j int) bool { return catalog.MonsterIDs[i] < catalog.MonsterIDs[j] })
	for _, groups := range catalog.Modes {
		for i := range groups {
			if names, ok := metadata.Groups[groups[i].ID]; ok {
				groups[i].Names = names
			}
		}
	}
	catalog.Sources = append(catalog.Sources, "Nanoka "+metadata.Version)
}

func parsePositiveUint32(value string) (uint32, error) {
	parsed, err := strconv.ParseUint(value, 10, 32)
	if err != nil || parsed == 0 {
		return 0, fmt.Errorf("invalid positive id %q", value)
	}
	return uint32(parsed), nil
}