package logic

import (
	"context"
	"strings"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"

	"easygoadmin/api/v1"
	"easygoadmin/internal/consts"
	"easygoadmin/internal/dao"
	"easygoadmin/internal/service"
)

// ============================== 城市业务实现 ==============================

// sCity 城市业务实现
// 实现 service.ICity 接口，承载城市模块的业务逻辑
type sCity struct{}

// citySerializeMaps 枚举字段到字典编码的映射
// {field}Text 由 dict_item 解析，字典管理页可修改文案
var citySerializeMaps = map[string]string{
	"level": "city_level",
}

func init() {
	service.RegisterCity(&sCity{})
}

// citySpec 城市模块声明
//
// 仅 Page 采用声明式；List 含 parentCode、limit 等特有查询，Detail 使用嵌入结构，均手写实现
var citySpec = ModuleSpec[v1.CityItem, v1.CityItem, v1.CityDetailRes]{
	Model:         dao.City.Ctx,
	LikeFields:    []string{"name", "pinyin"},
	EqFields:      []string{"level"},
	OrderBy:       "id",
	SerializeMaps: citySerializeMaps,
	ToData:        cityToData,
}

// cityToData 全量表单语义转换
// 兼容新增与修改请求，将入参转换为落库字段
func cityToData(req any) map[string]any {
	switch r := req.(type) {
	case *v1.CityAddReq:
		return map[string]any{
			"city_code": r.CityCode, "area_code": r.AreaCode, "parent_code": r.ParentCode,
			"zip_code": r.ZipCode, "level": r.Level, "pid": r.Pid, "name": r.Name,
			"short_name": r.ShortName, "full_name": r.FullName, "pinyin": r.Pinyin,
			"lng": r.Lng, "lat": r.Lat,
		}
	case *v1.CityUpdateReq:
		return map[string]any{
			"city_code": r.CityCode, "area_code": r.AreaCode, "parent_code": r.ParentCode,
			"zip_code": r.ZipCode, "level": r.Level, "pid": r.Pid, "name": r.Name,
			"short_name": r.ShortName, "full_name": r.FullName, "pinyin": r.Pinyin,
			"lng": r.Lng, "lat": r.Lat,
		}
	}
	panic("cityToData: 不支持的入参类型")
}

// Page 城市分页
// 按查询条件分页返回城市列表，采用声明式实现
func (s *sCity) Page(ctx context.Context, req *v1.CityPageReq) (res *v1.CityPageRes, err error) {
	list, total, err := citySpec.Page(ctx, req, req.GetPageNo(), req.GetPageSize())
	if err != nil {
		return nil, err
	}
	return v1.NewPageData(req.GetPageNo(), req.GetPageSize(), total, derefSlice(list)), nil
}

// List 城市列表
// 按父级编码、层级、关键词等条件返回城市列表，供级联选择器使用
func (s *sCity) List(ctx context.Context, req *v1.CityListReq) (res v1.CityListRes, err error) {
	m := dao.City.Ctx(ctx)
	if req.ParentCode != "" {
		m = m.Where("parent_code", req.ParentCode)
	} else if req.Level > 0 {
		m = m.Where("level", req.Level)
	}
	if req.Keyword != "" {
		kw := "%" + req.Keyword + "%"
		m = m.WhereLike("name", kw).WhereOrLike("pinyin", kw)
	}
	if req.Limit > 0 {
		m = m.Limit(req.Limit)
	}
	rows, err := m.Order("id").All()
	if err != nil {
		return nil, err
	}
	list := make([]v1.CityItem, 0, len(rows))
	for _, r := range rows {
		list = append(list, s.toItem(ctx, r))
	}
	return list, nil
}

// Detail 城市详情
// 按城市ID查询详情，并补充父级名称
func (s *sCity) Detail(ctx context.Context, req *v1.CityDetailReq) (res *v1.CityDetailRes, err error) {
	one, err := dao.City.Ctx(ctx).Where("id", req.Id).One()
	if err != nil {
		return nil, err
	}
	if len(one) == 0 {
		return nil, gerror.NewCode(consts.CodeRecordNotFound)
	}
	res = &v1.CityDetailRes{CityItem: s.toItem(ctx, one)}
	if pid := one["pid"].Int64(); pid > 0 {
		if parent, e := dao.City.Ctx(ctx).Where("id", pid).Fields("name").One(); e == nil && len(parent) > 0 {
			res.ParentName = parent["name"].String()
		}
	}
	return res, nil
}

// Add 新增城市
// 新增成功后返回新记录ID，采用声明式实现
func (s *sCity) Add(ctx context.Context, req *v1.CityAddReq) (res *v1.IdRes, err error) {
	id, err := citySpec.Add(ctx, req)
	if err != nil {
		return nil, err
	}
	return &v1.IdRes{Id: id}, nil
}

// Update 修改城市
// 按城市ID更新记录，采用声明式实现
func (s *sCity) Update(ctx context.Context, req *v1.CityUpdateReq) (res *v1.CityUpdateRes, err error) {
	if err = citySpec.Update(ctx, req.Id, req); err != nil {
		return nil, err
	}
	return &v1.CityUpdateRes{}, nil
}

// Delete 删除城市
// 按城市ID删除单条记录，采用声明式实现
func (s *sCity) Delete(ctx context.Context, req *v1.CityDeleteReq) (res *v1.CityDeleteRes, err error) {
	if err = citySpec.Delete(ctx, req.Id); err != nil {
		return nil, err
	}
	return &v1.CityDeleteRes{}, nil
}

// BatchDelete 批量删除城市
// 按城市ID列表批量删除记录，采用声明式实现
func (s *sCity) BatchDelete(ctx context.Context, req *v1.CityBatchDeleteReq) (res *v1.CityBatchDeleteRes, err error) {
	if err = citySpec.BatchDelete(ctx, req.Ids); err != nil {
		return nil, err
	}
	return &v1.CityBatchDeleteRes{}, nil
}

// ByParent 按父编码查询下级城市
// 登录用户即可访问，返回指定父级下的直属下级城市
func (s *sCity) ByParent(ctx context.Context, req *v1.CityByParentReq) (res *v1.CityByParentRes, err error) {
	rows, err := dao.City.Ctx(ctx).Where("parent_code", req.ParentCode).Order("id").All()
	if err != nil {
		return nil, err
	}
	list := make([]v1.CityItem, 0, len(rows))
	for _, r := range rows {
		list = append(list, s.toItem(ctx, r))
	}
	return &v1.CityByParentRes{List: list}, nil
}

// GetCityList 按父编码获取下级城市
// 登录用户即可访问，供级联选择器懒加载；parentCode 为 0 时返回顶级
func (s *sCity) GetCityList(ctx context.Context, req *v1.CityGetListReq) (res v1.CityGetListRes, err error) {
	rows, err := dao.City.Ctx(ctx).Where("parent_code", req.ParentCode).Order("id").All()
	if err != nil {
		return nil, err
	}
	list := make([]v1.CityItem, 0, len(rows))
	for _, r := range rows {
		list = append(list, s.toItem(ctx, r))
	}
	return list, nil
}

// AreaProvince 省份列表
// 登录用户即可访问，返回层级为省的顶级城市列表
func (s *sCity) AreaProvince(ctx context.Context, req *v1.AreaParentReq) (res *v1.AreaParentRes, err error) {
	rows, err := dao.City.Ctx(ctx).Where("level", 1).Order("id").All()
	if err != nil {
		return nil, err
	}
	list := make([]v1.CityItem, 0, len(rows))
	for _, r := range rows {
		list = append(list, s.toItem(ctx, r))
	}
	return &v1.AreaParentRes{List: list}, nil
}

// ============================================================
// 城市编解码（名称 ↔ 编码互转）
// ============================================================

// ResolveCityNames 城市编码数组转名称串
//
// 按 area_code 查询 name，保留输入顺序，空编码跳过。
// 例：["320000000000","320100000000","320105000000"] 转换为 "江苏省,南京市,建邺区"
func ResolveCityNames(ctx context.Context, codes []string, separator string) string {
	clean := make([]string, 0, len(codes))
	for _, c := range codes {
		if c != "" {
			clean = append(clean, c)
		}
	}
	if len(clean) == 0 {
		return ""
	}
	rows, err := dao.City.Ctx(ctx).WhereIn("area_code", clean).Fields("area_code, name").All()
	if err != nil {
		return ""
	}
	nameByCode := make(map[string]string, len(rows))
	for _, r := range rows {
		nameByCode[r["area_code"].String()] = r["name"].String()
	}
	names := make([]string, 0, len(clean))
	for _, code := range clean {
		if n := nameByCode[code]; n != "" {
			names = append(names, n)
		}
	}
	if separator == "" {
		separator = ","
	}
	return strings.Join(names, separator)
}

// ResolveCityCodes 名称串转四级编码数组
//
// 逐级以 parent 约束避免同名歧义。
// 例："江苏省,南京市,建邺区" 转换为 ["320000000000","320100000000","320105000000",""]
func ResolveCityCodes(ctx context.Context, cityInfo string) [4]string {
	var codes [4]string
	cityInfo = strings.TrimSpace(cityInfo)
	if cityInfo == "" {
		return codes
	}
	names := make([]string, 0, 4)
	for _, part := range strings.Split(cityInfo, ",") {
		if p := strings.TrimSpace(part); p != "" {
			names = append(names, p)
		}
	}
	if len(names) == 0 {
		return codes
	}
	// 第一级：省（pid = 0）
	prov, err := dao.City.Ctx(ctx).Where("pid", 0).Where("name", names[0]).One()
	if err != nil || len(prov) == 0 {
		return codes
	}
	codes[0] = prov["area_code"].String()
	// 第二级：市（parent_code = 省 area_code）
	if len(names) > 1 {
		if city, e := dao.City.Ctx(ctx).Where("parent_code", codes[0]).Where("name", names[1]).One(); e == nil && len(city) > 0 {
			codes[1] = city["area_code"].String()
		}
	}
	// 第三级：区（parent_code = 市 area_code）
	if len(names) > 2 && codes[1] != "" {
		if dist, e := dao.City.Ctx(ctx).Where("parent_code", codes[1]).Where("name", names[2]).One(); e == nil && len(dist) > 0 {
			codes[2] = dist["area_code"].String()
		}
	}
	// 第四级：街道（parent_code = 区 area_code）
	if len(names) > 3 && codes[2] != "" {
		if street, e := dao.City.Ctx(ctx).Where("parent_code", codes[2]).Where("name", names[3]).One(); e == nil && len(street) > 0 {
			codes[3] = street["area_code"].String()
		}
	}
	return codes
}

// toItem 数据库记录转换为城市行数据
// 枚举层级同步补全层级文本
func (s *sCity) toItem(ctx context.Context, r gdb.Record) v1.CityItem {
	return v1.CityItem{
		Id:         r["id"].Int64(),
		CityCode:   r["city_code"].String(),
		AreaCode:   r["area_code"].String(),
		ParentCode: r["parent_code"].String(),
		ZipCode:    r["zip_code"].String(),
		Level:      r["level"].Int(),
		LevelText:  DictGetText(ctx, citySerializeMaps["level"], r["level"].Int()),
		Pid:        r["pid"].Int64(),
		Name:       r["name"].String(),
		ShortName:  r["short_name"].String(),
		FullName:   r["full_name"].String(),
		Pinyin:     r["pinyin"].String(),
		Lng:        r["lng"].String(),
		Lat:        r["lat"].String(),
	}
}