package web

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"sync"
	"time"

	"rond-with-you/internal/geo"
)

// 按名称搜坐标：调用高德 Web 服务接口，密钥只在服务端拼接。
// 高德返回的就是 GCJ-02，与库内坐标同系，前端拿到即可直接入库，无需任何坐标转换。
const (
	amapPlaceTextURL = "https://restapi.amap.com/v3/place/text"  // 关键字/POI 搜索，适合地名
	amapGeocodeURL   = "https://restapi.amap.com/v3/geocode/geo" // 结构化地址解析，POI 无结果时兜底
)

var geocodeHTTPClient = &http.Client{Timeout: 8 * time.Second}

// geocodeItem 是返回给前端的候选点。
type geocodeItem struct {
	Name     string  `json:"name"`
	Address  string  `json:"address"`
	Lat      float64 `json:"lat"`
	Lon      float64 `json:"lon"`
	Province string  `json:"province"`
	City     string  `json:"city"`
	District string  `json:"district"`
}

// apiGeocode 供后台「新增地点」的搜索框使用，仅管理员可调用。
func (s *Server) apiGeocode(w http.ResponseWriter, r *http.Request) {
	if s.cfg.GeocodeKey == "" {
		s.json(w, map[string]any{"error": "服务端未配置 geocode_key，暂时无法按名称搜索坐标"})
		return
	}
	q := strings.TrimSpace(r.URL.Query().Get("q"))
	if q == "" {
		s.json(w, map[string]any{"error": "请输入要搜索的名称"})
		return
	}
	ctx, cancel := context.WithTimeout(r.Context(), 8*time.Second)
	defer cancel()

	items, err := s.amapSearchPOI(ctx, q)
	if err != nil {
		s.json(w, map[string]any{"error": err.Error()})
		return
	}
	if len(items) == 0 {
		// 地块/门牌这类不是 POI 的地址，再走一次结构化地理编码
		items, err = s.amapGeocode(ctx, q)
		if err != nil {
			s.json(w, map[string]any{"error": err.Error()})
			return
		}
	}
	if len(items) == 0 {
		s.json(w, map[string]any{"error": "没有找到匹配的地点，换个更完整的名称试试"})
		return
	}
	s.json(w, map[string]any{"items": items})
}

func (s *Server) amapSearchPOI(ctx context.Context, q string) ([]geocodeItem, error) {
	v := url.Values{}
	v.Set("key", s.cfg.GeocodeKey)
	v.Set("keywords", q)
	v.Set("offset", "8")
	v.Set("page", "1")
	v.Set("extensions", "base")
	body, err := s.amapGet(ctx, amapPlaceTextURL+"?"+v.Encode())
	if err != nil {
		return nil, err
	}
	var raw struct {
		Status string `json:"status"`
		Info   string `json:"info"`
		Pois   []struct {
			Name     string          `json:"name"`
			Location string          `json:"location"`
			Address  json.RawMessage `json:"address"`
			Pname    json.RawMessage `json:"pname"`
			Cityname json.RawMessage `json:"cityname"`
			Adname   json.RawMessage `json:"adname"`
		} `json:"pois"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	if raw.Status != "1" {
		return nil, &geoErr{"高德返回：" + raw.Info}
	}
	out := make([]geocodeItem, 0, len(raw.Pois))
	for _, p := range raw.Pois {
		lon, lat, ok := splitLocation(p.Location)
		if !ok {
			continue
		}
		out = append(out, geocodeItem{
			Name: p.Name, Address: amapStr(p.Address), Lat: lat, Lon: lon,
			Province: amapStr(p.Pname), City: amapStr(p.Cityname), District: amapStr(p.Adname),
		})
	}
	return out, nil
}

func (s *Server) amapGeocode(ctx context.Context, q string) ([]geocodeItem, error) {
	v := url.Values{}
	v.Set("key", s.cfg.GeocodeKey)
	v.Set("address", q)
	body, err := s.amapGet(ctx, amapGeocodeURL+"?"+v.Encode())
	if err != nil {
		return nil, err
	}
	var raw struct {
		Status   string `json:"status"`
		Info     string `json:"info"`
		Geocodes []struct {
			FormattedAddress string          `json:"formatted_address"`
			Location         string          `json:"location"`
			Province         json.RawMessage `json:"province"`
			City             json.RawMessage `json:"city"`
			District         json.RawMessage `json:"district"`
		} `json:"geocodes"`
	}
	if err := json.Unmarshal(body, &raw); err != nil {
		return nil, err
	}
	if raw.Status != "1" {
		return nil, &geoErr{"高德返回：" + raw.Info}
	}
	out := make([]geocodeItem, 0, len(raw.Geocodes))
	for _, g := range raw.Geocodes {
		lon, lat, ok := splitLocation(g.Location)
		if !ok {
			continue
		}
		out = append(out, geocodeItem{
			Name: g.FormattedAddress, Address: g.FormattedAddress, Lat: lat, Lon: lon,
			Province: amapStr(g.Province), City: amapStr(g.City), District: amapStr(g.District),
		})
	}
	return out, nil
}

func (s *Server) amapGet(ctx context.Context, u string) ([]byte, error) {
	// 网络抖动很常见，失败退避重试几次；限速令牌每次请求都要重新领
	var lastErr error
	for attempt := 0; attempt < 3; attempt++ {
		if attempt > 0 {
			select {
			case <-time.After(time.Duration(attempt) * 400 * time.Millisecond):
			case <-ctx.Done():
				return nil, ctx.Err()
			}
		}
		select {
		case <-amapLimiter.C:
		case <-ctx.Done():
			return nil, ctx.Err()
		}
		req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
		if err != nil {
			return nil, err
		}
		req.Header.Set("User-Agent", "rond-with-you/1.0")
		resp, err := geocodeHTTPClient.Do(req)
		if err != nil {
			lastErr = &geoErr{"请求高德失败：" + err.Error()}
			continue
		}
		body, readErr := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
		resp.Body.Close()
		if resp.StatusCode != http.StatusOK {
			lastErr = &geoErr{"高德返回 " + resp.Status}
			continue
		}
		if readErr != nil {
			lastErr = &geoErr{"读取高德响应失败：" + readErr.Error()}
			continue
		}
		return body, nil
	}
	return nil, lastErr
}

// amapStr 处理高德字段既可能是字符串、也可能是空数组的情况（直辖市常为空数组）。
func amapStr(raw json.RawMessage) string {
	if len(raw) == 0 {
		return ""
	}
	var s string
	if json.Unmarshal(raw, &s) == nil {
		return s
	}
	var arr []string
	if json.Unmarshal(raw, &arr) == nil && len(arr) > 0 {
		return arr[0]
	}
	return ""
}

// splitLocation 解析高德的 "经度,纬度"。
func splitLocation(v string) (lon, lat float64, ok bool) {
	a, b, found := strings.Cut(strings.TrimSpace(v), ",")
	if !found {
		return 0, 0, false
	}
	lon, err1 := strconv.ParseFloat(strings.TrimSpace(a), 64)
	lat, err2 := strconv.ParseFloat(strings.TrimSpace(b), 64)
	if err1 != nil || err2 != nil {
		return 0, 0, false
	}
	return lon, lat, true
}

type geoErr struct{ msg string }

func (e *geoErr) Error() string { return e.msg }

// ---------- 逆地理编码（坐标 -> 地址），照片导入用 ----------

// regeoItem 是一个坐标反查到的地址信息。坐标是**转换后**的 GCJ-02
// （EXIF 是 WGS-84，前端把原始值发上来，这里统一转，避免两份实现）。
type regeoItem struct {
	// Key 由调用方给（照片导入里是行号）：同一坐标可能被多张照片共用，
	// 服务端做了去重，没有这个 key 就配不回原来的行。
	Key      string  `json:"key"`
	Lat      float64 `json:"lat"`
	Lon      float64 `json:"lon"`
	Address  string  `json:"address"`
	Province string  `json:"province"`
	City     string  `json:"city"`
	District string  `json:"district"`
	Street   string  `json:"street"`
	Township string  `json:"township"`
	// Poi / PoiDist 是最近的兴趣点（店名）与距离（米）——
	// 照片导入里用它判断「这个点到底在哪儿」，比只给街道好认得多
	Poi     string  `json:"poi"`
	PoiDist float64 `json:"poiDist"`
}

const regeoURL = "https://restapi.amap.com/v3/geocode/regeo"
const aroundURL = "https://restapi.amap.com/v3/place/around"

// 高德对免费 key 有 QPS 限制，一次性甩几十个请求容易被限流（返回
// CUQPS_HAS_EXCEEDED_THE_LIMIT）。所有高德请求统一在这里排队，按 10 次/秒放行。
const amapQPS = 10

// amapLimiter 是全局限速器：令牌在每次真正发请求前领取，
// 所以一个点位内部发几次请求（regeo + 周边搜索）也照样受限。
var amapLimiter = time.NewTicker(time.Second / amapQPS)

// apiRegeo 批量把坐标换成地址：照片导入时用来让用户判断「这个点对不对」。
// 只传坐标、不传照片；相同坐标会去重，避免同一地点拍多张时重复调用。
func (s *Server) apiRegeo(w http.ResponseWriter, r *http.Request) {
	if s.cfg.GeocodeKey == "" {
		s.json(w, map[string]any{"error": "服务端未配置 geocode_key，无法反查地址"})
		return
	}
	var req struct {
		Coord  string `json:"coord"`
		Points []struct {
			Lat float64 `json:"lat"`
			Lon float64 `json:"lon"`
			Key string  `json:"key"`
		} `json:"points"`
	}
	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&req); err != nil {
		s.json(w, map[string]any{"error": "请求格式不对"})
		return
	}
	if len(req.Points) > 200 {
		s.json(w, map[string]any{"error": "一次最多反查 200 个坐标"})
		return
	}
	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
	defer cancel()

	// 先把坐标规整成 GCJ-02（EXIF 是 WGS-84；部分国产手机可能已经是 GCJ-02，由前端选择）
	type job struct {
		lat, lon float64
		dedup    string // 去重用
		keys     []string
	}
	jobs := make([]job, 0, len(req.Points))
	at := map[string]int{}
	for _, p := range req.Points {
		lat, lon := p.Lat, p.Lon
		if req.Coord != "gcj02" {
			lat, lon = geo.WGS84ToGCJ02(lat, lon)
		}
		// 5 位小数约 1 米：同一地点拍的多张只查一次，省配额也省时间
		k := fmt.Sprintf("%.5f,%.5f", lat, lon)
		if i, ok := at[k]; ok {
			jobs[i].keys = append(jobs[i].keys, p.Key)
			continue
		}
		at[k] = len(jobs)
		jobs = append(jobs, job{lat: lat, lon: lon, dedup: k, keys: []string{p.Key}})
	}

	// 一个去重后的点位可能对应多行，结果按行返回（key 原样带回）
	perJob := make([]regeoItem, len(jobs))
	sem := make(chan struct{}, 4) // 限并发；速率由 amapGet 里的全局限速器控制
	var wg sync.WaitGroup
	for i, j := range jobs {
		if ctx.Err() != nil {
			break
		}
		wg.Add(1)
		go func(i int, j job) {
			defer wg.Done()
			sem <- struct{}{}
			defer func() { <-sem }()
			item := regeoItem{Lat: j.lat, Lon: j.lon}
			if addr, prov, city, dist, street, town, ok := s.amapRegeo(ctx, j.lat, j.lon); ok {
				item.Address, item.Province, item.City = addr, prov, city
				item.District, item.Street, item.Township = dist, street, town
			}
			// 最近的地点（店名）：regeo 返回的 pois 多是行政单位，
			// 用周边搜索按距离排序取第一条才是店名
			if name, dist, ok := s.amapNearestPOI(ctx, j.lat, j.lon); ok {
				item.Poi, item.PoiDist = name, dist
			}
			perJob[i] = item
		}(i, j)
	}
	wg.Wait()

	items := make([]regeoItem, 0, len(req.Points))
	for i, j := range jobs {
		for _, k := range j.keys {
			it := perJob[i]
			it.Key = k
			items = append(items, it)
		}
	}
	s.json(w, map[string]any{"items": items})
}

// amapNearestPOI 找坐标附近最近的一个兴趣点（店名）。
// 半径给 200 米：再大容易匹配到马路边上不相干的店；取不到就返回 ok=false，
// 界面上只显示地址。
func (s *Server) amapNearestPOI(ctx context.Context, lat, lon float64) (name string, dist float64, ok bool) {
	v := url.Values{}
	v.Set("key", s.cfg.GeocodeKey)
	v.Set("location", fmt.Sprintf("%.6f,%.6f", lon, lat))
	v.Set("radius", "200")
	v.Set("offset", "1")
	v.Set("sortrule", "distance") // 按距离排序，第一条就是最近的
	body, err := s.amapGet(ctx, aroundURL+"?"+v.Encode())
	if err != nil {
		return "", 0, false
	}
	var raw struct {
		Status string `json:"status"`
		Pois   []struct {
			Name     string `json:"name"`
			Distance string `json:"distance"`
		} `json:"pois"`
	}
	if err := json.Unmarshal(body, &raw); err != nil || raw.Status != "1" || len(raw.Pois) == 0 {
		return "", 0, false
	}
	d, _ := strconv.ParseFloat(raw.Pois[0].Distance, 64)
	return raw.Pois[0].Name, d, true
}

// amapRegeo 调一次高德的逆地理编码。失败返回 ok=false，调用方留空即可。
func (s *Server) amapRegeo(ctx context.Context, lat, lon float64) (addr, prov, city, dist, street, town string, ok bool) {
	v := url.Values{}
	v.Set("key", s.cfg.GeocodeKey)
	// 高德要的是「经度,纬度」
	v.Set("location", fmt.Sprintf("%.6f,%.6f", lon, lat))
	v.Set("extensions", "base")
	body, err := s.amapGet(ctx, regeoURL+"?"+v.Encode())
	if err != nil {
		return
	}
	var raw struct {
		Status    string `json:"status"`
		Regeocode struct {
			Formatted string `json:"formatted_address"`
			Comp      struct {
				Province json.RawMessage `json:"province"`
				City     json.RawMessage `json:"city"`
				District json.RawMessage `json:"district"`
				Township json.RawMessage `json:"township"`
				StreetN  struct {
					Street json.RawMessage `json:"street"`
				} `json:"streetNumber"`
			} `json:"addressComponent"`
		} `json:"regeocode"`
	}
	if err := json.Unmarshal(body, &raw); err != nil || raw.Status != "1" {
		return "", "", "", "", "", "", false
	}
	return raw.Regeocode.Formatted,
		amapStr(raw.Regeocode.Comp.Province), amapStr(raw.Regeocode.Comp.City),
		amapStr(raw.Regeocode.Comp.District), amapStr(raw.Regeocode.Comp.StreetN.Street),
		amapStr(raw.Regeocode.Comp.Township), true
}