// Package api 提供HTTP API处理器
package api

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"server/internal/exporter"
	"server/internal/schema"
	"strings"
	"time"
)

// ==================== 模板API处理器 ====================

// TemplatesAPI 模板管理API
type TemplatesAPI struct {
	metaDB      *sql.DB // 元数据库（存储模板和任务）
	marketingDB *sql.DB // 营销系统数据库
}

// TemplatesHandler 创建模板API处理器
func TemplatesHandler(metaDB, marketingDB *sql.DB) http.Handler {
	api := &TemplatesAPI{metaDB: metaDB, marketingDB: marketingDB}
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		path := strings.TrimPrefix(r.URL.Path, "/api/templates")

		// POST /api/templates - 创建模板
		if r.Method == http.MethodPost && path == "" {
			api.createTemplate(w, r)
			return
		}

		// GET /api/templates - 获取模板列表
		if r.Method == http.MethodGet && path == "" {
			api.listTemplates(w, r)
			return
		}

		// 带ID的路径处理
		if strings.HasPrefix(path, "/") {
			templateID := strings.TrimPrefix(path, "/")

			// GET /api/templates/:id - 获取单个模板
			if r.Method == http.MethodGet {
				api.getTemplate(w, r, templateID)
				return
			}

			// PATCH /api/templates/:id - 更新模板
			if r.Method == http.MethodPatch {
				api.patchTemplate(w, r, templateID)
				return
			}

			// DELETE /api/templates/:id - 删除模板
			if r.Method == http.MethodDelete {
				api.deleteTemplate(w, r, templateID)
				return
			}

			// POST /api/templates/:id/validate - 验证模板
			if r.Method == http.MethodPost && strings.HasSuffix(path, "/validate") {
				templateID = strings.TrimSuffix(templateID, "/validate")
				api.validateTemplate(w, r, templateID)
				return
			}
		}

		fail(w, r, http.StatusNotFound, "not found")
	})
}

// ==================== 请求/响应结构 ====================

// TemplatePayload 模板创建/更新请求体
type TemplatePayload struct {
	Name       string                 `json:"name"`
	Datasource string                 `json:"datasource"`
	MainTable  string                 `json:"main_table"`
	Fields     []string               `json:"fields"`
	Filters    map[string]interface{} `json:"filters"`
	FileFormat string                 `json:"file_format"`
	OwnerID    uint64                 `json:"owner_id"`
	Visibility string                 `json:"visibility"`
}

// ==================== API方法 ====================

// createTemplate 创建新模板
func (api *TemplatesAPI) createTemplate(w http.ResponseWriter, r *http.Request) {
	// 读取并解析请求体
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("trace_id=%s error reading request body: %v", TraceIDFrom(r), err)
		fail(w, r, http.StatusBadRequest, "invalid request body")
		return
	}

	var payload TemplatePayload
	if err := json.Unmarshal(body, &payload); err != nil {
		log.Printf("trace_id=%s error parsing JSON: %v", TraceIDFrom(r), err)
		fail(w, r, http.StatusBadRequest, "invalid JSON format")
		return
	}

	r = WithPayload(r, payload)

	// 介URL参数获取用户ID
	if userIDStr := r.URL.Query().Get("userId"); userIDStr != "" {
		var userID uint64
		if _, scanErr := fmt.Sscan(userIDStr, &userID); scanErr == nil && userID > 0 {
			payload.OwnerID = userID
		}
	}

	// 插入数据库
	now := time.Now()
	insertSQL := `INSERT INTO export_templates 
		(name, datasource, main_table, fields_json, filters_json, file_format, 
		 visibility, owner_id, enabled, stats_enabled, last_validated_at, created_at, updated_at) 
		VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`

	args := []interface{}{
		payload.Name,
		payload.Datasource,
		payload.MainTable,
		toJSON(payload.Fields),
		toJSON(payload.Filters),
		payload.FileFormat,
		payload.Visibility,
		payload.OwnerID,
		1,   // enabled
		0,   // stats_enabled
		now, // last_validated_at
		now, // created_at
		now, // updated_at
	}

	log.Printf("trace_id=%s sql=%s args=%v", TraceIDFrom(r), insertSQL, args)

	if _, err := api.metaDB.Exec(insertSQL, args...); err != nil {
		fail(w, r, http.StatusInternalServerError, err.Error())
		return
	}

	writeJSON(w, r, http.StatusCreated, 0, "ok", nil)
}

// listTemplates 获取模板列表
func (api *TemplatesAPI) listTemplates(w http.ResponseWriter, r *http.Request) {
	userIDStr := r.URL.Query().Get("userId")

	// 构建查询SQL
	querySQL := `SELECT id, name, datasource, main_table, file_format, visibility, 
		owner_id, enabled, last_validated_at, created_at, updated_at, fields_json,
		(SELECT COUNT(1) FROM export_jobs ej WHERE ej.template_id = export_templates.id) AS exec_count 
		FROM export_templates`

	var args []interface{}
	var conditions []string

	if userIDStr != "" {
		conditions = append(conditions, "owner_id IN (0, ?)")
		args = append(args, userIDStr)
	}
	conditions = append(conditions, "enabled = 1")

	if len(conditions) > 0 {
		querySQL += " WHERE " + strings.Join(conditions, " AND ")
	}
	querySQL += " ORDER BY datasource ASC, id DESC LIMIT 200"

	rows, err := api.metaDB.Query(querySQL, args...)
	if err != nil {
		fail(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	defer rows.Close()

	whitelist := Whitelist()
	templates := []map[string]interface{}{}

	for rows.Next() {
		var (
			id              uint64
			name            string
			datasource      string
			mainTable       string
			fileFormat      string
			visibility      string
			ownerID         uint64
			enabled         int
			lastValidatedAt sql.NullTime
			createdAt       time.Time
			updatedAt       time.Time
			fieldsRaw       []byte
			execCount       int64
		)

		if err := rows.Scan(&id, &name, &datasource, &mainTable, &fileFormat, &visibility,
			&ownerID, &enabled, &lastValidatedAt, &createdAt, &updatedAt, &fieldsRaw, &execCount); err != nil {
			fail(w, r, http.StatusInternalServerError, err.Error())
			return
		}

		// 解析字段并计算有效字段数
		var fields []string
		_ = json.Unmarshal(fieldsRaw, &fields)
		fieldCount := countValidFields(datasource, mainTable, fields, whitelist)

		templates = append(templates, map[string]interface{}{
			"id":                id,
			"name":              name,
			"datasource":        datasource,
			"main_table":        mainTable,
			"file_format":       fileFormat,
			"visibility":        visibility,
			"owner_id":          ownerID,
			"enabled":           enabled == 1,
			"last_validated_at": lastValidatedAt.Time,
			"created_at":        createdAt,
			"updated_at":        updatedAt,
			"field_count":       fieldCount,
			"exec_count":        execCount,
		})
	}

	ok(w, r, templates)
}

// countValidFields 计算有效字段数（去重）
func countValidFields(datasource, mainTable string, fields []string, whitelist map[string]bool) int64 {
	seen := map[string]struct{}{}

	for _, field := range fields {
		// YMT系统的order_info映射为order
		if datasource == "ymt" && strings.HasPrefix(field, "order_info.") {
			field = strings.Replace(field, "order_info.", "order.", 1)
		}

		// 检查白名单
		if !whitelist[field] {
			continue
		}

		// YMT系统客户名称去重
		if datasource == "ymt" && field == "order.merchant_name" {
			if _, exists := seen["merchant.name"]; exists {
				continue
			}
		}

		if _, exists := seen[field]; exists {
			continue
		}
		seen[field] = struct{}{}
	}

	return int64(len(seen))
}

// getTemplate 获取单个模板详情
func (api *TemplatesAPI) getTemplate(w http.ResponseWriter, r *http.Request, templateID string) {
	querySQL := `SELECT id, name, datasource, main_table, fields_json, filters_json, 
		file_format, visibility, owner_id, enabled, explain_score, 
		last_validated_at, created_at, updated_at 
		FROM export_templates WHERE id=?`

	row := api.metaDB.QueryRow(querySQL, templateID)

	var (
		id              uint64
		name            string
		datasource      string
		mainTable       string
		fileFormat      string
		visibility      string
		ownerID         uint64
		enabled         int
		explainScore    sql.NullInt64
		lastValidatedAt sql.NullTime
		createdAt       time.Time
		updatedAt       time.Time
		fieldsJSON      []byte
		filtersJSON     []byte
	)

	err := row.Scan(&id, &name, &datasource, &mainTable, &fieldsJSON, &filtersJSON,
		&fileFormat, &visibility, &ownerID, &enabled, &explainScore,
		&lastValidatedAt, &createdAt, &updatedAt)
	if err != nil {
		fail(w, r, http.StatusNotFound, "not found")
		return
	}

	result := map[string]interface{}{
		"id":                id,
		"name":              name,
		"datasource":        datasource,
		"main_table":        mainTable,
		"file_format":       fileFormat,
		"visibility":        visibility,
		"owner_id":          ownerID,
		"enabled":           enabled == 1,
		"explain_score":     explainScore.Int64,
		"last_validated_at": lastValidatedAt.Time,
		"created_at":        createdAt,
		"updated_at":        updatedAt,
		"fields":            fromJSON(fieldsJSON),
		"filters":           fromJSON(filtersJSON),
	}

	ok(w, r, result)
}

// patchTemplate 更新模板
func (api *TemplatesAPI) patchTemplate(w http.ResponseWriter, r *http.Request, templateID string) {
	traceID := TraceIDFrom(r)

	// 读取请求体
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("trace_id=%s error reading request body: %v", traceID, err)
		fail(w, r, http.StatusBadRequest, "invalid request body")
		return
	}

	log.Printf("trace_id=%s patchTemplate request body: %s", traceID, string(body))

	// 解析JSON
	var payload map[string]interface{}
	if err := json.Unmarshal(body, &payload); err != nil {
		log.Printf("trace_id=%s error unmarshaling request body: %v", traceID, err)
		fail(w, r, http.StatusBadRequest, "invalid JSON format")
		return
	}

	log.Printf("trace_id=%s patchTemplate parsed payload: %v", traceID, payload)
	log.Printf("trace_id=%s patchTemplate template ID: %s", traceID, templateID)

	// 构建UPDATE语句
	var setClauses []string
	var args []interface{}

	for key, value := range payload {
		log.Printf("trace_id=%s patchTemplate processing field: %s, value: %v, type: %T", traceID, key, value, value)

		switch key {
		case "name", "visibility", "file_format", "main_table":
			if strVal, isStr := value.(string); isStr {
				setClauses = append(setClauses, key+"=?")
				args = append(args, strVal)
				log.Printf("trace_id=%s patchTemplate added string field: %s, value: %s", traceID, key, strVal)
			} else {
				log.Printf("trace_id=%s patchTemplate invalid string field: %s, value: %v, type: %T", traceID, key, value, value)
			}

		case "fields":
			setClauses = append(setClauses, "fields_json=?")
			jsonBytes := toJSON(value)
			args = append(args, jsonBytes)
			log.Printf("trace_id=%s patchTemplate added fields_json: %s", traceID, string(jsonBytes))

		case "filters":
			setClauses = append(setClauses, "filters_json=?")
			jsonBytes := toJSON(value)
			args = append(args, jsonBytes)
			log.Printf("trace_id=%s patchTemplate added filters_json: %s", traceID, string(jsonBytes))

		case "enabled":
			setClauses = append(setClauses, "enabled=?")
			if boolVal, isBool := value.(bool); isBool {
				if boolVal {
					args = append(args, 1)
				} else {
					args = append(args, 0)
				}
				log.Printf("trace_id=%s patchTemplate added enabled: %t", traceID, boolVal)
			} else {
				log.Printf("trace_id=%s patchTemplate invalid bool field: %s, value: %v, type: %T", traceID, key, value, value)
			}
		}
	}

	if len(setClauses) == 0 {
		log.Printf("trace_id=%s patchTemplate no fields to update", traceID)
		fail(w, r, http.StatusBadRequest, "no patch")
		return
	}

	// 添加updated_at
	setClauses = append(setClauses, "updated_at=?")
	now := time.Now()
	args = append(args, now, templateID)

	updateSQL := "UPDATE export_templates SET " + strings.Join(setClauses, ",") + " WHERE id= ?"
	log.Printf("trace_id=%s patchTemplate executing SQL: %s", traceID, updateSQL)
	log.Printf("trace_id=%s patchTemplate SQL args: %v", traceID, args)

	if _, err := api.metaDB.Exec(updateSQL, args...); err != nil {
		log.Printf("trace_id=%s patchTemplate SQL error: %v", traceID, err)
		fail(w, r, http.StatusInternalServerError, err.Error())
		return
	}

	log.Printf("trace_id=%s patchTemplate update successful", traceID)
	ok(w, r, nil)
}

// deleteTemplate 删除模板
func (api *TemplatesAPI) deleteTemplate(w http.ResponseWriter, r *http.Request, templateID string) {
	// 检查是否有关联的导出任务
	var jobCount int64
	row := api.metaDB.QueryRow("SELECT COUNT(1) FROM export_jobs WHERE template_id=?", templateID)
	_ = row.Scan(&jobCount)

	if jobCount > 0 {
		// 有关联任务，检查是否要求软删除
		softDelete := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("soft")))
		if softDelete == "1" || softDelete == "true" || softDelete == "yes" {
			// 软删除：禁用模板
			_, _ = api.metaDB.Exec("UPDATE export_templates SET enabled=?, updated_at=? WHERE id=?", 0, time.Now(), templateID)
			ok(w, r, nil)
			return
		}
		fail(w, r, http.StatusBadRequest, "template in use")
		return
	}

	// 无关联任务，硬删除
	if _, err := api.metaDB.Exec("DELETE FROM export_templates WHERE id=?", templateID); err != nil {
		fail(w, r, http.StatusInternalServerError, err.Error())
		return
	}

	ok(w, r, nil)
}

// validateTemplate 验证模板
func (api *TemplatesAPI) validateTemplate(w http.ResponseWriter, r *http.Request, templateID string) {
	// 获取模板信息
	row := api.metaDB.QueryRow(
		"SELECT datasource, main_table, fields_json, filters_json FROM export_templates WHERE id=?",
		templateID,
	)

	var (
		datasource  string
		mainTable   string
		fieldsJSON  []byte
		filtersJSON []byte
	)

	if err := row.Scan(&datasource, &mainTable, &fieldsJSON, &filtersJSON); err != nil {
		fail(w, r, http.StatusNotFound, "not found")
		return
	}

	// 解析字段和过滤条件
	var fields []string
	var filters map[string]interface{}
	_ = json.Unmarshal(fieldsJSON, &fields)
	_ = json.Unmarshal(filtersJSON, &filters)

	// 构建SQL
	whitelist := Whitelist()
	request := exporter.BuildRequest{
		MainTable:  mainTable,
		Datasource: datasource,
		Fields:     fields,
		Filters:    filters,
	}

	query, args, err := exporter.BuildSQL(request, whitelist)
	if err != nil {
		failCat(w, r, http.StatusBadRequest, err.Error(), "sql_build_error")
		return
	}

	// 执行EXPLAIN分析
	dataDB := api.selectDataDB(datasource)
	score, suggestions, err := exporter.EvaluateExplain(dataDB, query, args)
	if err != nil {
		failCat(w, r, http.StatusBadRequest, err.Error(), "explain_error")
		return
	}

	// 添加索引建议
	indexSuggestions := exporter.IndexSuggestions(request)
	suggestions = append(suggestions, indexSuggestions...)

	// 更新模板的验证结果
	explainResult := map[string]interface{}{
		"sql":         query,
		"suggestions": suggestions,
	}
	now := time.Now()
	_, _ = api.metaDB.Exec(
		"UPDATE export_templates SET explain_json=?, explain_score=?, last_validated_at=?, updated_at=? WHERE id=?",
		toJSON(explainResult), score, now, now, templateID,
	)

	ok(w, r, map[string]interface{}{
		"score":       score,
		"suggestions": suggestions,
	})
}

// selectDataDB 根据数据源选择对应的数据库连接
func (api *TemplatesAPI) selectDataDB(datasource string) *sql.DB {
	if datasource == "ymt" {
		return api.metaDB // YMT数据在meta库
	}
	return api.marketingDB
}

// ==================== 辅助函数 ====================

// toJSON 将对象转换为JSON字节
func toJSON(v interface{}) []byte {
	b, _ := json.Marshal(v)
	return b
}

// fromJSON 将JSON字节解析为对象
func fromJSON(b []byte) interface{} {
	var v interface{}
	_ = json.Unmarshal(b, &v)
	return v
}

// Whitelist 获取字段白名单
func Whitelist() map[string]bool {
	return schema.AllWhitelist()
}

// FieldLabels 获取字段标签映射
func FieldLabels() map[string]string {
	return schema.AllLabels()
}