package app

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"math"
	"net/http"
	"strconv"
	"strings"
	"time"
)

type profileView struct {
	ID             int64    `json:"id"`
	PublicID       string   `json:"publicId"`
	Nickname       string   `json:"nickname"`
	Avatar         string   `json:"avatar"`
	Cover          string   `json:"cover"`
	Gender         int      `json:"gender"`
	Age            int      `json:"age"`
	Height         int      `json:"height"`
	City           string   `json:"city"`
	Bio            string   `json:"bio"`
	VIP            bool     `json:"vip"`
	VIPLevel       int      `json:"vipLevel"`
	Online         bool     `json:"online"`
	Distance       float64  `json:"distance"`
	DistanceText   string   `json:"distanceText"`
	FollowingCount int      `json:"followingCount"`
	FollowerCount  int      `json:"followerCount"`
	PostCount      int      `json:"postCount"`
	LikeCount      int      `json:"likeCount"`
	Following      bool     `json:"following"`
	Liked          bool     `json:"liked"`
	Tags           []string `json:"tags"`
}

func (a *App) loadProfile(r *http.Request, id, viewerID int64) (profileView, error) {
	var item profileView
	var birthday sql.NullTime
	var active sql.NullTime
	var vip int
	err := a.db.QueryRowContext(r.Context(), `SELECT u.id,u.public_id,p.nickname,p.avatar_url,p.cover_url,p.gender,p.birthday,COALESCE(p.height_cm,0),p.city_name,p.bio,p.is_vip,p.vip_level,p.last_active_at,
		(SELECT COUNT(*) FROM user_follows WHERE user_id=u.id),(SELECT COUNT(*) FROM user_follows WHERE target_user_id=u.id),(SELECT COUNT(*) FROM posts WHERE user_id=u.id AND status=1),(SELECT COUNT(*) FROM post_likes pl JOIN posts po ON po.id=pl.post_id WHERE po.user_id=u.id),
		EXISTS(SELECT 1 FROM user_follows WHERE user_id=? AND target_user_id=u.id),EXISTS(SELECT 1 FROM user_likes WHERE user_id=? AND target_user_id=u.id)
		FROM users u JOIN user_profiles p ON p.user_id=u.id WHERE u.id=? AND u.status=1`, viewerID, viewerID, id).Scan(
		&item.ID, &item.PublicID, &item.Nickname, &item.Avatar, &item.Cover, &item.Gender, &birthday, &item.Height, &item.City, &item.Bio, &vip, &item.VIPLevel, &active, &item.FollowingCount, &item.FollowerCount, &item.PostCount, &item.LikeCount, &item.Following, &item.Liked)
	if err != nil {
		return item, err
	}
	item.VIP = vip == 1
	if birthday.Valid {
		item.Age = age(birthday.Time)
	}
	item.Online = active.Valid && time.Since(active.Time) < 15*time.Minute
	item.Tags = []string{"摄影爱好者", "旅行达人", "天秤座"}
	return item, nil
}

func (a *App) userProfile(w http.ResponseWriter, r *http.Request) {
	id, err := pathID(r)
	if err != nil {
		fail(w, 400, 20001, "invalid id")
		return
	}
	who := current(r)
	if id != who.ID {
		_, _ = a.db.ExecContext(r.Context(), `INSERT INTO profile_visits (viewer_user_id,target_user_id,source) VALUES (?,?,'profile')`, who.ID, id)
	}
	item, err := a.loadProfile(r, id, who.ID)
	if err != nil {
		fail(w, 404, 30001, "用户不存在")
		return
	}
	reply(w, item)
}

func (a *App) discover(w http.ResponseWriter, r *http.Request) { a.discoverList(w, r, false) }
func (a *App) nearby(w http.ResponseWriter, r *http.Request)   { a.discoverList(w, r, true) }

func (a *App) discoverList(w http.ResponseWriter, r *http.Request, byDistance bool) {
	who := current(r)
	gender, _ := strconv.Atoi(r.URL.Query().Get("gender"))
	scope := r.URL.Query().Get("scope")
	sortMode := r.URL.Query().Get("sort")
	query := `SELECT u.id,u.public_id,p.nickname,p.avatar_url,p.cover_url,p.gender,p.birthday,COALESCE(p.height_cm,0),p.city_name,p.bio,p.is_vip,p.vip_level,p.last_active_at,l.latitude,l.longitude,
		EXISTS(SELECT 1 FROM user_follows f WHERE f.user_id=? AND f.target_user_id=u.id),EXISTS(SELECT 1 FROM user_likes x WHERE x.user_id=? AND x.target_user_id=u.id)
		FROM users u JOIN user_profiles p ON p.user_id=u.id LEFT JOIN user_location_states l ON l.user_id=u.id
		WHERE u.status=1 AND u.id<>? AND NOT EXISTS(SELECT 1 FROM user_blocks b WHERE (b.user_id=? AND b.blocked_user_id=u.id) OR (b.user_id=u.id AND b.blocked_user_id=?))`
	args := []any{who.ID, who.ID, who.ID, who.ID, who.ID}
	if scope == "following" {
		query += ` AND EXISTS(SELECT 1 FROM user_follows mine WHERE mine.user_id=? AND mine.target_user_id=u.id)`
		args = append(args, who.ID)
	}
	if gender > 0 {
		query += ` AND p.gender=?`
		args = append(args, gender)
	}
	if sortMode == "latest" {
		query += ` ORDER BY p.last_active_at DESC,u.id DESC LIMIT 50`
	} else {
		query += ` ORDER BY p.is_vip DESC,p.last_active_at DESC LIMIT 50`
	}
	rows, err := a.db.QueryContext(r.Context(), query, args...)
	if err != nil {
		fail(w, 500, 50001, err.Error())
		return
	}
	defer rows.Close()
	items := []profileView{}
	var myLat, myLng sql.NullFloat64
	_ = a.db.QueryRowContext(r.Context(), `SELECT latitude,longitude FROM user_location_states WHERE user_id=?`, who.ID).Scan(&myLat, &myLng)
	for rows.Next() {
		var item profileView
		var birthday sql.NullTime
		var active sql.NullTime
		var lat, lng sql.NullFloat64
		var vip int
		if err := rows.Scan(&item.ID, &item.PublicID, &item.Nickname, &item.Avatar, &item.Cover, &item.Gender, &birthday, &item.Height, &item.City, &item.Bio, &vip, &item.VIPLevel, &active, &lat, &lng, &item.Following, &item.Liked); err != nil {
			continue
		}
		item.VIP = vip == 1
		if birthday.Valid {
			item.Age = age(birthday.Time)
		}
		item.Online = active.Valid && time.Since(active.Time) < 15*time.Minute
		if myLat.Valid && myLng.Valid && lat.Valid && lng.Valid {
			item.Distance = haversine(myLat.Float64, myLng.Float64, lat.Float64, lng.Float64)
			item.DistanceText = distanceText(item.Distance)
		}
		item.Tags = []string{"摄影", "旅行"}
		items = append(items, item)
	}
	if byDistance {
		sortProfilesByDistance(items)
	}
	reply(w, map[string]any{"items": items, "total": len(items)})
}

func (a *App) updateLocation(w http.ResponseWriter, r *http.Request) {
	var req struct {
		Latitude  float64 `json:"latitude"`
		Longitude float64 `json:"longitude"`
		CityCode  string  `json:"cityCode"`
	}
	if err := decode(r, &req); err != nil || req.Latitude == 0 || req.Longitude == 0 {
		fail(w, 400, 20001, "无效的位置")
		return
	}
	if req.CityCode == "" {
		req.CityCode = "310100"
	}
	_, err := a.db.ExecContext(r.Context(), `INSERT INTO user_location_states (user_id,city_code,location_cell,latitude,longitude,source) VALUES (?,?, 'wx4g',?,?,'gps') ON DUPLICATE KEY UPDATE city_code=VALUES(city_code),latitude=VALUES(latitude),longitude=VALUES(longitude),last_location_at=NOW(3),source='gps'`, current(r).ID, req.CityCode, req.Latitude, req.Longitude)
	if err != nil {
		fail(w, 500, 50001, "位置更新失败")
		return
	}
	reply(w, map[string]bool{"success": true})
}

func (a *App) follow(w http.ResponseWriter, r *http.Request) {
	a.relationship(w, r, "user_follows", true)
}
func (a *App) unfollow(w http.ResponseWriter, r *http.Request) {
	a.relationship(w, r, "user_follows", false)
}
func (a *App) likeUser(w http.ResponseWriter, r *http.Request) {
	a.relationship(w, r, "user_likes", true)
}
func (a *App) unlikeUser(w http.ResponseWriter, r *http.Request) {
	a.relationship(w, r, "user_likes", false)
}

func (a *App) relationship(w http.ResponseWriter, r *http.Request, table string, create bool) {
	target, err := pathID(r)
	if err != nil || target == current(r).ID {
		fail(w, 400, 20001, "无效用户")
		return
	}
	if create {
		if table == "user_likes" {
			_, err = a.db.ExecContext(r.Context(), `INSERT IGNORE INTO user_likes (user_id,target_user_id,source) VALUES (?,?,'profile')`, current(r).ID, target)
		} else {
			_, err = a.db.ExecContext(r.Context(), `INSERT IGNORE INTO user_follows (user_id,target_user_id) VALUES (?,?)`, current(r).ID, target)
		}
	} else {
		_, err = a.db.ExecContext(r.Context(), `DELETE FROM `+table+` WHERE user_id=? AND target_user_id=?`, current(r).ID, target)
	}
	if err != nil {
		fail(w, 500, 50001, "操作失败")
		return
	}
	reply(w, map[string]bool{"success": true})
}

type postView struct {
	ID           int64       `json:"id"`
	User         profileView `json:"user"`
	Content      string      `json:"content"`
	Location     string      `json:"location"`
	LikeCount    int         `json:"likeCount"`
	CommentCount int         `json:"commentCount"`
	Liked        bool        `json:"liked"`
	Media        []string    `json:"media"`
	CreatedAt    time.Time   `json:"createdAt"`
}

func (a *App) feed(w http.ResponseWriter, r *http.Request) {
	who := current(r)
	query := `SELECT p.id,p.user_id,p.content,p.location_text,p.like_count,p.comment_count,p.created_at,u.public_id,pr.nickname,pr.avatar_url,pr.gender,pr.is_vip,EXISTS(SELECT 1 FROM post_likes l WHERE l.post_id=p.id AND l.user_id=?) FROM posts p JOIN users u ON u.id=p.user_id JOIN user_profiles pr ON pr.user_id=p.user_id WHERE p.status=1 AND (p.visibility=1 OR p.user_id=? OR (p.visibility=2 AND EXISTS(SELECT 1 FROM user_follows audience WHERE audience.user_id=? AND audience.target_user_id=p.user_id)))`
	args := []any{who.ID, who.ID, who.ID}
	if r.URL.Query().Get("scope") == "following" {
		query += ` AND EXISTS(SELECT 1 FROM user_follows f WHERE f.user_id=? AND f.target_user_id=p.user_id)`
		args = append(args, who.ID)
	}
	query += ` ORDER BY p.created_at DESC LIMIT 50`
	rows, err := a.db.QueryContext(r.Context(), query, args...)
	if err != nil {
		fail(w, 500, 50001, err.Error())
		return
	}
	defer rows.Close()
	items := []postView{}
	for rows.Next() {
		var item postView
		var uid int64
		var vip int
		if rows.Scan(&item.ID, &uid, &item.Content, &item.Location, &item.LikeCount, &item.CommentCount, &item.CreatedAt, &item.User.PublicID, &item.User.Nickname, &item.User.Avatar, &item.User.Gender, &vip, &item.Liked) != nil {
			continue
		}
		item.User.ID = uid
		item.User.VIP = vip == 1
		mediaRows, _ := a.db.QueryContext(r.Context(), `SELECT media_url FROM post_media WHERE post_id=? ORDER BY sort_order`, item.ID)
		item.Media = []string{}
		if mediaRows != nil {
			for mediaRows.Next() {
				var url string
				_ = mediaRows.Scan(&url)
				item.Media = append(item.Media, url)
			}
			_ = mediaRows.Close()
		}
		items = append(items, item)
	}
	reply(w, map[string]any{"items": items, "total": len(items)})
}

func (a *App) createPost(w http.ResponseWriter, r *http.Request) {
	if a.isSanctionActive(r.Context(), current(r).ID, "CONTENT_LIMIT") {
		fail(w, http.StatusForbidden, 10006, "账号处于内容发布限制期")
		return
	}
	var req struct {
		Content    string   `json:"content"`
		Media      []string `json:"media"`
		Location   string   `json:"location"`
		Visibility int      `json:"visibility"`
	}
	if decode(r, &req) != nil || strings.TrimSpace(req.Content) == "" {
		fail(w, 400, 20001, "请输入动态内容")
		return
	}
	if req.Visibility != 2 {
		req.Visibility = 1
	}
	tx, _ := a.db.BeginTx(r.Context(), nil)
	result, err := tx.ExecContext(r.Context(), `INSERT INTO posts (user_id,content,visibility,city_code,location_text) VALUES (?,?,?,'310100',?)`, current(r).ID, req.Content, req.Visibility, req.Location)
	if err != nil {
		_ = tx.Rollback()
		fail(w, 500, 50001, "发布失败")
		return
	}
	id, _ := result.LastInsertId()
	for i, url := range req.Media {
		_, _ = tx.ExecContext(r.Context(), `INSERT INTO post_media(post_id,media_url,sort_order)VALUES(?,?,?)`, id, url, i)
	}
	_ = tx.Commit()
	reply(w, map[string]any{"id": id})
}

func (a *App) likePost(w http.ResponseWriter, r *http.Request)   { a.postLike(w, r, true) }
func (a *App) unlikePost(w http.ResponseWriter, r *http.Request) { a.postLike(w, r, false) }
func (a *App) postLike(w http.ResponseWriter, r *http.Request, create bool) {
	id, err := pathID(r)
	if err != nil {
		fail(w, 400, 20001, "invalid id")
		return
	}
	tx, _ := a.db.BeginTx(r.Context(), nil)
	if create {
		result, _ := tx.ExecContext(r.Context(), `INSERT IGNORE INTO post_likes(post_id,user_id)VALUES(?,?)`, id, current(r).ID)
		affected, _ := result.RowsAffected()
		if affected > 0 {
			_, _ = tx.ExecContext(r.Context(), `UPDATE posts SET like_count=like_count+1 WHERE id=?`, id)
		}
	} else {
		result, _ := tx.ExecContext(r.Context(), `DELETE FROM post_likes WHERE post_id=? AND user_id=?`, id, current(r).ID)
		affected, _ := result.RowsAffected()
		if affected > 0 {
			_, _ = tx.ExecContext(r.Context(), `UPDATE posts SET like_count=GREATEST(like_count-1,0) WHERE id=?`, id)
		}
	}
	_ = tx.Commit()
	reply(w, map[string]bool{"success": true})
}

func (a *App) comments(w http.ResponseWriter, r *http.Request) {
	id, _ := pathID(r)
	rows, err := a.db.QueryContext(r.Context(), `SELECT c.id,c.content,c.created_at,p.user_id,p.nickname,p.avatar_url FROM post_comments c JOIN user_profiles p ON p.user_id=c.user_id WHERE c.post_id=? AND c.status=1 ORDER BY c.created_at`, id)
	if err != nil {
		fail(w, 500, 50001, "查询失败")
		return
	}
	defer rows.Close()
	items := []map[string]any{}
	for rows.Next() {
		var cid, uid int64
		var content, nick, avatar string
		var created time.Time
		_ = rows.Scan(&cid, &content, &created, &uid, &nick, &avatar)
		items = append(items, map[string]any{"id": cid, "content": content, "createdAt": created, "user": map[string]any{"id": uid, "nickname": nick, "avatar": avatar}})
	}
	reply(w, map[string]any{"items": items})
}

func (a *App) createComment(w http.ResponseWriter, r *http.Request) {
	id, _ := pathID(r)
	var req struct {
		Content string `json:"content"`
	}
	if decode(r, &req) != nil || req.Content == "" {
		fail(w, 400, 20001, "评论不能为空")
		return
	}
	tx, _ := a.db.BeginTx(r.Context(), nil)
	result, err := tx.ExecContext(r.Context(), `INSERT INTO post_comments(post_id,user_id,content)VALUES(?,?,?)`, id, current(r).ID, req.Content)
	if err != nil {
		_ = tx.Rollback()
		fail(w, 500, 50001, "评论失败")
		return
	}
	_, _ = tx.ExecContext(r.Context(), `UPDATE posts SET comment_count=comment_count+1 WHERE id=?`, id)
	_ = tx.Commit()
	cid, _ := result.LastInsertId()
	reply(w, map[string]any{"id": cid})
}

func (a *App) createReport(w http.ResponseWriter, r *http.Request) {
	var req struct {
		TargetType  string `json:"targetType"`
		TargetID    int64  `json:"targetId"`
		Reason      string `json:"reason"`
		Description string `json:"description"`
	}
	if decode(r, &req) != nil || req.TargetID == 0 {
		fail(w, 400, 20001, "举报信息不完整")
		return
	}
	result, err := a.db.ExecContext(r.Context(), `INSERT INTO reports(reporter_user_id,target_type,target_id,reason_code,description)VALUES(?,?,?,?,?)`, current(r).ID, req.TargetType, req.TargetID, req.Reason, req.Description)
	if err != nil {
		fail(w, 500, 50001, "提交失败")
		return
	}
	id, _ := result.LastInsertId()
	reply(w, map[string]any{"id": id, "status": "PENDING"})
}

func age(birthday time.Time) int {
	now := time.Now()
	years := now.Year() - birthday.Year()
	if now.YearDay() < birthday.YearDay() {
		years--
	}
	return years
}
func haversine(lat1, lng1, lat2, lng2 float64) float64 {
	const earth = 6371
	dlat := (lat2 - lat1) * math.Pi / 180
	dlng := (lng2 - lng1) * math.Pi / 180
	a := math.Sin(dlat/2)*math.Sin(dlat/2) + math.Cos(lat1*math.Pi/180)*math.Cos(lat2*math.Pi/180)*math.Sin(dlng/2)*math.Sin(dlng/2)
	return earth * 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
}
func distanceText(value float64) string {
	if value < 1 {
		return fmt.Sprintf("%.2fkm", value)
	}
	return fmt.Sprintf("%.1fkm", value)
}
func sortProfilesByDistance(items []profileView) {
	for i := 0; i < len(items); i++ {
		for j := i + 1; j < len(items); j++ {
			if items[j].Distance < items[i].Distance {
				items[i], items[j] = items[j], items[i]
			}
		}
	}
}
func jsonBytes(value any) []byte { data, _ := json.Marshal(value); return data }