package repository

import (
	"database/sql"
	"fmt"
	"strings"

	"cmautobuy/admin/model"
)

// claimCandidateLimit 是一次最多尝试抢多少条。
// 抢不到说明被别的客户端拿走了，再试下一条；都抢不到就当作没任务。
const claimCandidateLimit = 10

// ClaimNextTask 为指定客户端领取一个任务。
//
// 没有可领的任务时返回 (nil, nil) —— 调用方据此返回 204。
//
// 防并发的做法是**条件更新 + 检查影响行数**：先查出候选，
// 再用 `WHERE task_id = ? AND status = 'assigned'` 去更新，
// 影响行数为 0 就说明被别人抢先了，换下一条。
// 不用 SELECT ... FOR UPDATE，SQLite 没有那个。
func ClaimNextTask(db *sql.DB, clientID string, supportedTypes []string) (*model.Task, error) {
	if clientID == "" {
		return nil, fmt.Errorf("client_id 不能为空")
	}

	query := `SELECT task_id FROM tasks
	          WHERE assigned_client = ? AND status = 'assigned'`
	args := []any{clientID}

	// 客户端只声明支持某些类型时，不要给它别的类型
	if len(supportedTypes) > 0 {
		placeholders := strings.TrimSuffix(strings.Repeat("?,", len(supportedTypes)), ",")
		query += ` AND task_type IN (` + placeholders + `)`
		for _, t := range supportedTypes {
			args = append(args, t)
		}
	}
	query += ` ORDER BY priority DESC, created_at LIMIT ?`
	args = append(args, claimCandidateLimit)

	rows, err := db.Query(query, args...)
	if err != nil {
		return nil, fmt.Errorf("查询可领任务失败: %w", err)
	}
	var candidates []string
	for rows.Next() {
		var id string
		if err := rows.Scan(&id); err != nil {
			rows.Close()
			return nil, fmt.Errorf("读取候选任务失败: %w", err)
		}
		candidates = append(candidates, id)
	}
	rows.Close()
	if err := rows.Err(); err != nil {
		return nil, err
	}

	now := model.NowISO()
	for _, taskID := range candidates {
		res, err := db.Exec(`
			UPDATE tasks SET status = 'claimed', claimed_at = ?, updated_at = ?
			WHERE task_id = ? AND status = 'assigned'`,
			now, now, taskID)
		if err != nil {
			return nil, fmt.Errorf("领取任务 %s 失败: %w", taskID, err)
		}
		n, err := res.RowsAffected()
		if err != nil {
			return nil, err
		}
		if n == 0 {
			continue // 被别的客户端抢先了，换下一条
		}
		// 记一笔领取历史。提交结果时要靠它判断这台客户端有没有领过——
		// 任务重派后 assigned_client 会变，只看它就查不出来了。
		if err := RecordClaim(db, taskID, clientID, now); err != nil {
			return nil, err
		}
		return GetTask(db, taskID)
	}
	return nil, nil // 没有可领的任务
}

// GetTask 按编号读一条任务。
func GetTask(db *sql.DB, taskID string) (*model.Task, error) {
	var t model.Task
	var assigned, claimedAt, sybID, orderNo, goodsID, skuID sql.NullString
	var pddGoodsID, pddOptions, resultData, errCode, errMsg, finishedAt sql.NullString
	var quantity, maxPrice sql.NullInt64

	err := db.QueryRow(`
		SELECT task_id, task_type, status, version, priority,
		       assigned_client, claimed_at,
		       syb_id, order_no, goods_id, shopee_sku_id,
		       pdd_goods_url, pdd_goods_id, pdd_options,
		       quantity, max_price_cent,
		       result_data, error_code, error_message, finished_at,
		       created_at, updated_at
		FROM tasks WHERE task_id = ?`, taskID).Scan(
		&t.TaskID, &t.TaskType, &t.Status, &t.Version, &t.Priority,
		&assigned, &claimedAt,
		&sybID, &orderNo, &goodsID, &skuID,
		&t.PddGoodsURL, &pddGoodsID, &pddOptions,
		&quantity, &maxPrice,
		&resultData, &errCode, &errMsg, &finishedAt,
		&t.CreatedAt, &t.UpdatedAt)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, fmt.Errorf("读取任务 %s 失败: %w", taskID, err)
	}

	t.AssignedClient = assigned.String
	t.ClaimedAt = claimedAt.String
	t.SybID = sybID.String
	t.OrderNo = orderNo.String
	t.GoodsID = goodsID.String
	t.ShopeeSKUID = skuID.String
	t.PddGoodsID = pddGoodsID.String
	t.PddOptions = pddOptions.String
	t.Quantity = int(quantity.Int64)
	t.MaxPriceCent = maxPrice.Int64
	t.ResultData = resultData.String
	t.ErrorCode = errCode.String
	t.ErrorMessage = errMsg.String
	t.FinishedAt = finishedAt.String
	return &t, nil
}

// RecordClaim 记一笔"某客户端领过某任务"。
//
// 同一台客户端重复领同一个任务时只更新时间，不报错。
func RecordClaim(q Execer, taskID, clientID, claimedAt string) error {
	_, err := q.Exec(`
		INSERT INTO task_claims (task_id, client_id, claimed_at)
		VALUES (?, ?, ?)
		ON CONFLICT(task_id, client_id) DO UPDATE SET claimed_at = excluded.claimed_at`,
		taskID, clientID, claimedAt)
	if err != nil {
		return fmt.Errorf("记录领取历史失败 task=%s client=%s: %w", taskID, clientID, err)
	}
	return nil
}

// HasEverClaimed 判断这台客户端**曾经**领过这个任务。
//
// 用于提交结果时的权限判断：只有从没领过的才拒绝（403）。
// 任务已取消、已重派给别人，都**不影响**这个判断——
// 契约要求那些情况仍然要接受结果，见 docs/admin/04-client-api.md §4.1。
func HasEverClaimed(q Execer, taskID, clientID string) (bool, error) {
	var one int
	err := q.QueryRow(
		`SELECT 1 FROM task_claims WHERE task_id = ? AND client_id = ?`,
		taskID, clientID).Scan(&one)
	if err == sql.ErrNoRows {
		return false, nil
	}
	if err != nil {
		return false, fmt.Errorf("查询领取历史失败: %w", err)
	}
	return true, nil
}

// TaskExists 判断任务在不在，并返回它的类型和关联的蝦皮商品编号。
func TaskExists(q Execer, taskID string) (exists bool, taskType model.TaskType, goodsID string, err error) {
	var gid sql.NullString
	e := q.QueryRow(
		`SELECT task_type, goods_id FROM tasks WHERE task_id = ?`,
		taskID).Scan(&taskType, &gid)
	if e == sql.ErrNoRows {
		return false, "", "", nil
	}
	if e != nil {
		return false, "", "", fmt.Errorf("查询任务 %s 失败: %w", taskID, e)
	}
	return true, taskType, gid.String, nil
}

// MarkTaskSucceeded 记录成功结果。
//
// `[必须]` **不检查任务当前状态**。任务已取消、已重派给别的客户端，
// 都照样接受——客户端可能真的已经下单了，这些数据必须能留痕。
// 理由见 docs/admin/04-client-api.md §4.1。
func MarkTaskSucceeded(q Execer, taskID, resultData string) error {
	now := model.NowISO()
	_, err := q.Exec(`
		UPDATE tasks
		   SET status = 'succeeded', result_data = ?, finished_at = ?, updated_at = ?
		 WHERE task_id = ?`,
		resultData, now, now, taskID)
	if err != nil {
		return fmt.Errorf("标记任务 %s 成功失败: %w", taskID, err)
	}
	return nil
}

// MarkTaskFailure 记录失败/需人工处理的结果。
//
// status 由客户端报告，映射规则见 docs/admin/04-client-api.md §5：
//
//	retry_wait    -> assigned（放回去等它再来领）
//	manual_review -> manual_review
//	failed        -> failed
//	cancelled     -> cancelled
//
// 同样**不检查任务当前状态**，理由同 MarkTaskSucceeded。
func MarkTaskFailure(q Execer, taskID string, newStatus model.TaskStatus, errCode, errMsg string) error {
	now := model.NowISO()

	// 放回待领取的话不算结束，finished_at 保持为空
	finishedAt := any(now)
	if newStatus == model.TaskAssigned {
		finishedAt = nil
	}

	_, err := q.Exec(`
		UPDATE tasks
		   SET status = ?, error_code = ?, error_message = ?,
		       finished_at = ?, updated_at = ?
		 WHERE task_id = ?`,
		newStatus, errCode, errMsg, finishedAt, now, taskID)
	if err != nil {
		return fmt.Errorf("标记任务 %s 失败状态出错: %w", taskID, err)
	}
	return nil
}