package appconfig

import (
	"errors"
	"fmt"
	"strings"
	"time"
	"unicode"
	"unicode/utf8"

	"hyapp-admin-server/internal/appctx"
	"hyapp-admin-server/internal/model"
	"hyapp-admin-server/internal/repository"
)

const h5LinkGroup = "h5-links"

const (
	bannerDisplayScopeHome     = "home"
	bannerDisplayScopeRoom     = "room"
	bannerDisplayScopeRecharge = "recharge"

	bannerStatusActive   = "active"
	bannerStatusDisabled = "disabled"
	bannerStatusExpired  = "expired"
)

var bannerDisplayScopeOrder = []string{bannerDisplayScopeHome, bannerDisplayScopeRoom, bannerDisplayScopeRecharge}

type AppConfigService struct {
	store *repository.Store
}

type H5Link struct {
	Key         string `json:"key"`
	Label       string `json:"label"`
	URL         string `json:"url"`
	UpdatedAtMs int64  `json:"updatedAtMs"`
}

type AppBanner struct {
	ID                uint     `json:"id"`
	AppCode           string   `json:"appCode"`
	CoverURL          string   `json:"coverUrl"`
	RoomSmallImageURL string   `json:"roomSmallImageUrl"`
	BannerType        string   `json:"bannerType"`
	DisplayScope      string   `json:"displayScope"`
	DisplayScopes     []string `json:"displayScopes"`
	Param             string   `json:"param"`
	Status            string   `json:"status"`
	Platform          string   `json:"platform"`
	SortOrder         int      `json:"sortOrder"`
	RegionID          int64    `json:"regionId"`
	CountryCode       string   `json:"countryCode"`
	Description       string   `json:"description"`
	StartsAtMs        int64    `json:"startsAtMs"`
	EndsAtMs          int64    `json:"endsAtMs"`
	CreatedAtMs       int64    `json:"createdAtMs"`
	UpdatedAtMs       int64    `json:"updatedAtMs"`
}

type AppVersion struct {
	ID          uint   `json:"id"`
	AppCode     string `json:"appCode"`
	Platform    string `json:"platform"`
	Version     string `json:"version"`
	BuildNumber int64  `json:"buildNumber"`
	ForceUpdate bool   `json:"forceUpdate"`
	DownloadURL string `json:"downloadUrl"`
	Description string `json:"description"`
	CreatedAtMs int64  `json:"createdAtMs"`
	UpdatedAtMs int64  `json:"updatedAtMs"`
}

type ExploreTab struct {
	ID          uint   `json:"id"`
	AppCode     string `json:"appCode"`
	Tab         string `json:"tab"`
	H5URL       string `json:"h5Url"`
	Enabled     bool   `json:"enabled"`
	SortOrder   int    `json:"sortOrder"`
	CreatedAtMs int64  `json:"createdAtMs"`
	UpdatedAtMs int64  `json:"updatedAtMs"`
}

func NewService(store *repository.Store) *AppConfigService {
	return &AppConfigService{store: store}
}

func (s *AppConfigService) ListH5Links() ([]H5Link, error) {
	configs, err := s.store.ListAppConfigs(h5LinkGroup)
	if err != nil {
		return nil, err
	}

	items := make([]H5Link, 0, len(configs))
	for _, config := range configs {
		items = append(items, h5LinkFromModel(config))
	}
	return items, nil
}

func (s *AppConfigService) UpdateH5Links(request updateH5LinksRequest) ([]H5Link, error) {
	if len(request.Items) == 0 {
		return nil, errors.New("items are required")
	}

	items := make([]model.AppConfig, 0, len(request.Items))
	seen := make(map[string]struct{}, len(request.Items))
	for _, item := range request.Items {
		config, err := h5LinkModelFromPayload(item)
		if err != nil {
			return nil, err
		}
		key := config.Key
		if _, ok := seen[key]; ok {
			return nil, fmt.Errorf("duplicate h5 link key: %s", key)
		}
		seen[key] = struct{}{}
		items = append(items, config)
	}

	if err := s.store.UpsertAppConfigs(items); err != nil {
		return nil, err
	}
	return s.ListH5Links()
}

func (s *AppConfigService) CreateH5Link(req h5LinkPayload) (H5Link, error) {
	item, err := h5LinkModelFromPayload(req)
	if err != nil {
		return H5Link{}, err
	}
	if err := s.store.CreateAppConfig(&item); err != nil {
		return H5Link{}, err
	}
	return h5LinkFromModel(item), nil
}

func (s *AppConfigService) UpdateH5Link(key string, req h5LinkPayload) (H5Link, error) {
	item, err := s.store.GetAppConfig(h5LinkGroup, key)
	if err != nil {
		return H5Link{}, err
	}
	req.Key = item.Key
	updated, err := h5LinkModelFromPayload(req)
	if err != nil {
		return H5Link{}, err
	}
	item.Value = updated.Value
	item.Description = updated.Description
	if err := s.store.UpdateAppConfig(&item); err != nil {
		return H5Link{}, err
	}
	return h5LinkFromModel(item), nil
}

func (s *AppConfigService) DeleteH5Link(key string) error {
	return s.store.DeleteAppConfig(h5LinkGroup, key)
}

func (s *AppConfigService) ListBanners(appCode string, options repository.AppBannerListOptions) ([]AppBanner, error) {
	options.AppCode = appctx.Normalize(appCode)
	options.Status = normalizeBannerStatus(options.Status)
	if strings.TrimSpace(options.DisplayScope) != "" {
		options.DisplayScope = normalizeBannerDisplayScope(options.DisplayScope)
	}
	options.Platform = normalizeBannerPlatform(options.Platform)
	options.Country = normalizeCountryCode(options.Country)
	options.Keyword = strings.TrimSpace(options.Keyword)
	if err := s.store.ExpireAppBanners(options.AppCode, time.Now().UTC().UnixMilli()); err != nil {
		return nil, err
	}
	items, err := s.store.ListAppBanners(options)
	if err != nil {
		return nil, err
	}
	out := make([]AppBanner, 0, len(items))
	for _, item := range items {
		out = append(out, appBannerFromModel(item))
	}
	return out, nil
}

func (s *AppConfigService) CreateBanner(appCode string, req bannerRequest) (AppBanner, error) {
	item, err := bannerModelFromRequest(appctx.Normalize(appCode), req)
	if err != nil {
		return AppBanner{}, err
	}
	if err := s.store.CreateAppBanner(&item); err != nil {
		return AppBanner{}, err
	}
	return appBannerFromModel(item), nil
}

func (s *AppConfigService) UpdateBanner(appCode string, id uint, req bannerRequest) (AppBanner, error) {
	item, err := s.store.GetAppBanner(appctx.Normalize(appCode), id)
	if err != nil {
		return AppBanner{}, err
	}
	updated, err := bannerModelFromRequest(item.AppCode, req)
	if err != nil {
		return AppBanner{}, err
	}
	item.CoverURL = updated.CoverURL
	item.RoomSmallImageURL = updated.RoomSmallImageURL
	item.BannerType = updated.BannerType
	item.DisplayScope = updated.DisplayScope
	item.Param = updated.Param
	item.Status = updated.Status
	item.Platform = updated.Platform
	item.SortOrder = updated.SortOrder
	item.RegionID = updated.RegionID
	item.CountryCode = updated.CountryCode
	item.Description = updated.Description
	item.StartsAtMS = updated.StartsAtMS
	item.EndsAtMS = updated.EndsAtMS
	if err := s.store.UpdateAppBanner(&item); err != nil {
		return AppBanner{}, err
	}
	return appBannerFromModel(item), nil
}

func (s *AppConfigService) DeleteBanner(appCode string, id uint) error {
	return s.store.DeleteAppBanner(appctx.Normalize(appCode), id)
}

func (s *AppConfigService) ListAppVersions(appCode string, options repository.AppVersionListOptions) ([]AppVersion, error) {
	options.AppCode = appctx.Normalize(appCode)
	options.Platform = normalizeAppPlatform(options.Platform)
	options.Keyword = strings.TrimSpace(options.Keyword)
	items, err := s.store.ListAppVersions(options)
	if err != nil {
		return nil, err
	}
	out := make([]AppVersion, 0, len(items))
	for _, item := range items {
		out = append(out, appVersionFromModel(item))
	}
	return out, nil
}

func (s *AppConfigService) CreateAppVersion(appCode string, req appVersionRequest) (AppVersion, error) {
	item, err := appVersionModelFromRequest(appctx.Normalize(appCode), req)
	if err != nil {
		return AppVersion{}, err
	}
	if err := s.store.CreateAppVersion(&item); err != nil {
		return AppVersion{}, err
	}
	return appVersionFromModel(item), nil
}

func (s *AppConfigService) UpdateAppVersion(appCode string, id uint, req appVersionRequest) (AppVersion, error) {
	item, err := s.store.GetAppVersion(appctx.Normalize(appCode), id)
	if err != nil {
		return AppVersion{}, err
	}
	updated, err := appVersionModelFromRequest(item.AppCode, req)
	if err != nil {
		return AppVersion{}, err
	}
	item.Platform = updated.Platform
	item.Version = updated.Version
	item.BuildNumber = updated.BuildNumber
	item.ForceUpdate = updated.ForceUpdate
	item.DownloadURL = updated.DownloadURL
	item.Description = updated.Description
	if err := s.store.UpdateAppVersion(&item); err != nil {
		return AppVersion{}, err
	}
	return appVersionFromModel(item), nil
}

func (s *AppConfigService) DeleteAppVersion(appCode string, id uint) error {
	return s.store.DeleteAppVersion(appctx.Normalize(appCode), id)
}

func (s *AppConfigService) ListExploreTabs(appCode string, options repository.AppExploreTabListOptions) ([]ExploreTab, error) {
	options.AppCode = appctx.Normalize(appCode)
	options.Keyword = strings.TrimSpace(options.Keyword)
	items, err := s.store.ListAppExploreTabs(options)
	if err != nil {
		return nil, err
	}
	out := make([]ExploreTab, 0, len(items))
	for _, item := range items {
		out = append(out, exploreTabFromModel(item))
	}
	return out, nil
}

func (s *AppConfigService) CreateExploreTab(appCode string, req exploreTabRequest) (ExploreTab, error) {
	item, err := exploreTabModelFromRequest(appctx.Normalize(appCode), req)
	if err != nil {
		return ExploreTab{}, err
	}
	if err := s.store.CreateAppExploreTab(&item); err != nil {
		return ExploreTab{}, err
	}
	return exploreTabFromModel(item), nil
}

func (s *AppConfigService) UpdateExploreTab(appCode string, id uint, req exploreTabRequest) (ExploreTab, error) {
	item, err := s.store.GetAppExploreTab(appctx.Normalize(appCode), id)
	if err != nil {
		return ExploreTab{}, err
	}
	updated, err := exploreTabModelFromRequest(item.AppCode, req)
	if err != nil {
		return ExploreTab{}, err
	}
	item.Tab = updated.Tab
	item.H5URL = updated.H5URL
	item.Enabled = updated.Enabled
	item.SortOrder = updated.SortOrder
	if err := s.store.UpdateAppExploreTab(&item); err != nil {
		return ExploreTab{}, err
	}
	return exploreTabFromModel(item), nil
}

func (s *AppConfigService) DeleteExploreTab(appCode string, id uint) error {
	return s.store.DeleteAppExploreTab(appctx.Normalize(appCode), id)
}

func validateH5URL(value string) error {
	if value == "" {
		return nil
	}
	if len(value) > 2048 {
		return errors.New("h5 link is too long")
	}
	for _, char := range value {
		if unicode.IsSpace(char) {
			return errors.New("h5 link cannot contain whitespace")
		}
	}
	return nil
}

func h5LinkModelFromPayload(req h5LinkPayload) (model.AppConfig, error) {
	key := strings.TrimSpace(req.Key)
	label := strings.TrimSpace(req.Label)
	url := strings.TrimSpace(req.URL)
	if err := validateH5Key(key); err != nil {
		return model.AppConfig{}, err
	}
	if label == "" || utf8.RuneCountInString(label) > 80 {
		return model.AppConfig{}, errors.New("h5 config label is invalid")
	}
	if url == "" {
		return model.AppConfig{}, errors.New("h5 link is required")
	}
	if err := validateH5URL(url); err != nil {
		return model.AppConfig{}, err
	}
	return model.AppConfig{
		Group:       h5LinkGroup,
		Key:         key,
		Value:       url,
		Description: label,
	}, nil
}

func validateH5Key(value string) error {
	if value == "" || len(value) > 80 {
		return errors.New("h5 config key is invalid")
	}
	for _, char := range value {
		switch {
		case char >= 'a' && char <= 'z':
		case char >= 'A' && char <= 'Z':
		case char >= '0' && char <= '9':
		case char == '-' || char == '_' || char == '.' || char == ':':
		default:
			return errors.New("h5 config key is invalid")
		}
	}
	return nil
}

func h5LinkFromModel(config model.AppConfig) H5Link {
	label := strings.TrimSpace(config.Description)
	if label == "" {
		label = config.Key
	}
	return H5Link{
		Key:         config.Key,
		Label:       label,
		URL:         config.Value,
		UpdatedAtMs: config.UpdatedAtMS,
	}
}

func bannerModelFromRequest(appCode string, req bannerRequest) (model.AppBanner, error) {
	displayScopes := normalizeBannerDisplayScopes(req.DisplayScopes, req.DisplayScope)
	item := model.AppBanner{
		AppCode:           appctx.Normalize(appCode),
		CoverURL:          strings.TrimSpace(req.CoverURL),
		RoomSmallImageURL: strings.TrimSpace(req.RoomSmallImageURL),
		BannerType:        normalizeBannerType(req.BannerType),
		DisplayScope:      bannerDisplayScopeValue(displayScopes),
		Param:             strings.TrimSpace(req.Param),
		Status:            normalizeBannerStatus(req.Status),
		Platform:          normalizeBannerPlatform(req.Platform),
		SortOrder:         req.SortOrder,
		RegionID:          req.RegionID,
		CountryCode:       normalizeCountryCode(req.CountryCode),
		Description:       strings.TrimSpace(req.Description),
		StartsAtMS:        req.StartsAtMs,
		EndsAtMS:          req.EndsAtMs,
	}
	if item.CoverURL == "" || len(item.CoverURL) > 1024 {
		return model.AppBanner{}, errors.New("banner cover is invalid")
	}
	if containsWhitespace(item.CoverURL) {
		return model.AppBanner{}, errors.New("banner cover cannot contain whitespace")
	}
	if !validBannerDisplayScopes(displayScopes) {
		return model.AppBanner{}, errors.New("banner display scope is invalid")
	}
	if bannerDisplayScopesContain(displayScopes, bannerDisplayScopeRoom) {
		if item.RoomSmallImageURL == "" || len(item.RoomSmallImageURL) > 1024 {
			return model.AppBanner{}, errors.New("room small image is required")
		}
		if containsWhitespace(item.RoomSmallImageURL) {
			return model.AppBanner{}, errors.New("room small image cannot contain whitespace")
		}
	} else {
		// 未投放到房间内时不保留小屏图，避免客户端误用房间专属素材。
		item.RoomSmallImageURL = ""
	}
	if item.BannerType != "h5" && item.BannerType != "app" {
		return model.AppBanner{}, errors.New("banner type is invalid")
	}
	if item.BannerType == "h5" {
		if item.Param == "" {
			return model.AppBanner{}, errors.New("h5 link is required")
		}
		if err := validateH5URL(item.Param); err != nil {
			return model.AppBanner{}, err
		}
	}
	if len(item.Param) > 2048 {
		return model.AppBanner{}, errors.New("banner param is too long")
	}
	if item.Status != bannerStatusActive && item.Status != bannerStatusDisabled && item.Status != bannerStatusExpired {
		return model.AppBanner{}, errors.New("banner status is invalid")
	}
	if item.StartsAtMS < 0 || item.EndsAtMS < 0 {
		return model.AppBanner{}, errors.New("banner delivery time is invalid")
	}
	if item.StartsAtMS > 0 && item.EndsAtMS > 0 && item.StartsAtMS >= item.EndsAtMS {
		return model.AppBanner{}, errors.New("banner delivery time range is invalid")
	}
	if item.Status == bannerStatusActive && item.EndsAtMS > 0 && item.EndsAtMS <= time.Now().UTC().UnixMilli() {
		item.Status = bannerStatusExpired
	}
	if item.Platform != "android" && item.Platform != "ios" {
		return model.AppBanner{}, errors.New("banner platform is invalid")
	}
	if item.RegionID < 0 {
		return model.AppBanner{}, errors.New("banner region is invalid")
	}
	if item.CountryCode != "" && !validCountryCode(item.CountryCode) {
		return model.AppBanner{}, errors.New("banner country is invalid")
	}
	if utf8.RuneCountInString(item.Description) > 255 {
		return model.AppBanner{}, errors.New("banner description is too long")
	}
	return item, nil
}

func appBannerFromModel(item model.AppBanner) AppBanner {
	return AppBanner{
		ID:                item.ID,
		AppCode:           item.AppCode,
		CoverURL:          item.CoverURL,
		RoomSmallImageURL: item.RoomSmallImageURL,
		BannerType:        item.BannerType,
		DisplayScope:      item.DisplayScope,
		DisplayScopes:     bannerDisplayScopeList(item.DisplayScope),
		Param:             item.Param,
		Status:            item.Status,
		Platform:          item.Platform,
		SortOrder:         item.SortOrder,
		RegionID:          item.RegionID,
		CountryCode:       item.CountryCode,
		Description:       item.Description,
		StartsAtMs:        item.StartsAtMS,
		EndsAtMs:          item.EndsAtMS,
		CreatedAtMs:       item.CreatedAtMS,
		UpdatedAtMs:       item.UpdatedAtMS,
	}
}

func appVersionModelFromRequest(appCode string, req appVersionRequest) (model.AppVersion, error) {
	item := model.AppVersion{
		AppCode:     appctx.Normalize(appCode),
		Platform:    normalizeAppPlatform(req.Platform),
		Version:     strings.TrimSpace(req.Version),
		BuildNumber: req.BuildNumber,
		ForceUpdate: req.ForceUpdate,
		DownloadURL: strings.TrimSpace(req.DownloadURL),
		Description: strings.TrimSpace(req.Description),
	}
	if item.Platform != "android" && item.Platform != "ios" {
		return model.AppVersion{}, errors.New("app version platform is invalid")
	}
	if item.Version == "" || utf8.RuneCountInString(item.Version) > 40 {
		return model.AppVersion{}, errors.New("app version is invalid")
	}
	if item.BuildNumber <= 0 {
		return model.AppVersion{}, errors.New("app build number is invalid")
	}
	if item.DownloadURL == "" || len(item.DownloadURL) > 2048 {
		return model.AppVersion{}, errors.New("app download url is invalid")
	}
	for _, char := range item.DownloadURL {
		if unicode.IsSpace(char) {
			return model.AppVersion{}, errors.New("app download url cannot contain whitespace")
		}
	}
	if utf8.RuneCountInString(item.Description) > 1000 {
		return model.AppVersion{}, errors.New("app version description is too long")
	}
	return item, nil
}

func appVersionFromModel(item model.AppVersion) AppVersion {
	return AppVersion{
		ID:          item.ID,
		AppCode:     item.AppCode,
		Platform:    item.Platform,
		Version:     item.Version,
		BuildNumber: item.BuildNumber,
		ForceUpdate: item.ForceUpdate,
		DownloadURL: item.DownloadURL,
		Description: item.Description,
		CreatedAtMs: item.CreatedAtMS,
		UpdatedAtMs: item.UpdatedAtMS,
	}
}

func exploreTabModelFromRequest(appCode string, req exploreTabRequest) (model.AppExploreTab, error) {
	item := model.AppExploreTab{
		AppCode:   appctx.Normalize(appCode),
		Tab:       strings.TrimSpace(req.Tab),
		H5URL:     strings.TrimSpace(req.H5URL),
		Enabled:   req.Enabled,
		SortOrder: req.SortOrder,
	}
	if item.Tab == "" || utf8.RuneCountInString(item.Tab) > 40 {
		return model.AppExploreTab{}, errors.New("explore tab is invalid")
	}
	if item.H5URL == "" || len(item.H5URL) > 2048 {
		return model.AppExploreTab{}, errors.New("explore h5 url is invalid")
	}
	if err := validateH5URL(item.H5URL); err != nil {
		return model.AppExploreTab{}, err
	}
	return item, nil
}

func exploreTabFromModel(item model.AppExploreTab) ExploreTab {
	return ExploreTab{
		ID:          item.ID,
		AppCode:     item.AppCode,
		Tab:         item.Tab,
		H5URL:       item.H5URL,
		Enabled:     item.Enabled,
		SortOrder:   item.SortOrder,
		CreatedAtMs: item.CreatedAtMS,
		UpdatedAtMs: item.UpdatedAtMS,
	}
}

func normalizeBannerType(value string) string {
	return strings.ToLower(strings.TrimSpace(value))
}

func normalizeBannerStatus(value string) string {
	value = strings.ToLower(strings.TrimSpace(value))
	if value == "" {
		return bannerStatusActive
	}
	return value
}

func normalizeBannerDisplayScope(value string) string {
	value = strings.ToLower(strings.TrimSpace(value))
	switch value {
	case "":
		return bannerDisplayScopeHome
	case bannerDisplayScopeHome, "首页":
		return bannerDisplayScopeHome
	case bannerDisplayScopeRoom, "房间内":
		return bannerDisplayScopeRoom
	case bannerDisplayScopeRecharge, "充值页":
		return bannerDisplayScopeRecharge
	default:
		return value
	}
}

func normalizeBannerDisplayScopes(values []string, fallback string) []string {
	seen := make(map[string]struct{}, len(bannerDisplayScopeOrder))
	for _, value := range values {
		for _, part := range strings.Split(value, ",") {
			scope := normalizeBannerDisplayScope(part)
			if scope == "" {
				continue
			}
			seen[scope] = struct{}{}
		}
	}
	if len(seen) == 0 {
		for _, part := range strings.Split(fallback, ",") {
			scope := normalizeBannerDisplayScope(part)
			if scope == "" {
				continue
			}
			seen[scope] = struct{}{}
		}
	}
	if len(seen) == 0 {
		seen[bannerDisplayScopeHome] = struct{}{}
	}
	out := make([]string, 0, len(seen))
	for _, scope := range bannerDisplayScopeOrder {
		if _, ok := seen[scope]; ok {
			out = append(out, scope)
			delete(seen, scope)
		}
	}
	for scope := range seen {
		out = append(out, scope)
	}
	return out
}

func bannerDisplayScopeList(value string) []string {
	return normalizeBannerDisplayScopes(nil, value)
}

func bannerDisplayScopeValue(scopes []string) string {
	return strings.Join(scopes, ",")
}

func validBannerDisplayScopes(scopes []string) bool {
	if len(scopes) == 0 {
		return false
	}
	for _, scope := range scopes {
		if scope != bannerDisplayScopeHome && scope != bannerDisplayScopeRoom && scope != bannerDisplayScopeRecharge {
			return false
		}
	}
	return true
}

func bannerDisplayScopesContain(scopes []string, target string) bool {
	for _, scope := range scopes {
		if scope == target {
			return true
		}
	}
	return false
}

func normalizeBannerPlatform(value string) string {
	return strings.ToLower(strings.TrimSpace(value))
}

func normalizeAppPlatform(value string) string {
	return strings.ToLower(strings.TrimSpace(value))
}

func normalizeCountryCode(value string) string {
	return strings.ToUpper(strings.TrimSpace(value))
}

func containsWhitespace(value string) bool {
	for _, char := range value {
		if unicode.IsSpace(char) {
			return true
		}
	}
	return false
}

func validCountryCode(value string) bool {
	if len(value) < 2 || len(value) > 3 {
		return false
	}
	for _, char := range value {
		if char < 'A' || char > 'Z' {
			return false
		}
	}
	return true
}