package helpers

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/spf13/cobra"
)

// ============================================================================
// set-style / batch-set-style 辅助函数与命令（透传 update_range 样式字段）
// ============================================================================

// parseA1Range 解析 A1 表示法（支持 "Sheet1!A1:B3" / "A1:B3" / "A1"），返回 rows/cols。
func parseA1Range(addr string) (rows, cols int, err error) {
	if i := strings.Index(addr, "!"); i >= 0 {
		addr = addr[i+1:]
	}
	addr = strings.TrimSpace(strings.ToUpper(addr))
	if addr == "" {
		return 0, 0, fmt.Errorf("range 不能为空")
	}
	parts := strings.SplitN(addr, ":", 2)
	c1, r1, err := parseA1Cell(parts[0])
	if err != nil {
		return 0, 0, err
	}
	c2, r2 := c1, r1
	if len(parts) == 2 {
		c2, r2, err = parseA1Cell(parts[1])
		if err != nil {
			return 0, 0, err
		}
	}
	if c2 < c1 {
		c1, c2 = c2, c1
	}
	if r2 < r1 {
		r1, r2 = r2, r1
	}
	return r2 - r1 + 1, c2 - c1 + 1, nil
}

func parseA1Cell(s string) (col, row int, err error) {
	var i int
	for i = 0; i < len(s); i++ {
		c := s[i]
		if c < 'A' || c > 'Z' {
			break
		}
		col = col*26 + int(c-'A'+1)
	}
	if i == 0 || i == len(s) {
		return 0, 0, fmt.Errorf("无效单元格地址: %s", s)
	}
	for _, c := range s[i:] {
		if c < '0' || c > '9' {
			return 0, 0, fmt.Errorf("无效单元格地址: %s", s)
		}
		row = row*10 + int(c-'0')
	}
	if row == 0 || col == 0 {
		return 0, 0, fmt.Errorf("无效单元格地址: %s", s)
	}
	return col, row, nil
}

func fillStringMatrix(rows, cols int, v string) [][]string {
	m := make([][]string, rows)
	for i := range m {
		row := make([]string, cols)
		for j := range row {
			row[j] = v
		}
		m[i] = row
	}
	return m
}

func fillIntMatrix(rows, cols int, v int) [][]int {
	m := make([][]int, rows)
	for i := range m {
		row := make([]int, cols)
		for j := range row {
			row[j] = v
		}
		m[i] = row
	}
	return m
}

var (
	hAlignEnum     = map[string]bool{"left": true, "center": true, "right": true, "general": true}
	vAlignEnum     = map[string]bool{"top": true, "middle": true, "bottom": true}
	fontWeightEnum = map[string]bool{"bold": true, "normal": true}
	wordWrapEnum   = map[string]bool{"overflow": true, "clip": true, "autoWrap": true}
)

// styleSpec 描述一次 set-style 调用的样式参数（与 CLI flag / 批次 JSON 对齐）。
type styleSpec struct {
	BgColor         string `json:"bgColor,omitempty"`
	BgColorsJSON    string `json:"bgColorsJson,omitempty"`
	FontSize        int    `json:"fontSize,omitempty"`
	FontSizesJSON   string `json:"fontSizesJson,omitempty"`
	HAlign          string `json:"hAlign,omitempty"`
	HAlignsJSON     string `json:"hAlignsJson,omitempty"`
	VAlign          string `json:"vAlign,omitempty"`
	VAlignsJSON     string `json:"vAlignsJson,omitempty"`
	FontColor       string `json:"fontColor,omitempty"`
	FontColorsJSON  string `json:"fontColorsJson,omitempty"`
	FontWeight      string `json:"fontWeight,omitempty"`
	FontWeightsJSON string `json:"fontWeightsJson,omitempty"`
	WordWrap        string `json:"wordWrap,omitempty"`
	NumberFormat    string `json:"numberFormat,omitempty"`
}

// batchItem 是 batch-set-style 批次配置里的一项
// 嵌入 styleSpec，额外必填 sheetId + range。
type batchItem struct {
	SheetID string `json:"sheetId"`
	Range   string `json:"range"`
	styleSpec
}

// applyStyleSpec 将 styleSpec 铺到 toolArgs，同时做枚举/维度/上限校验。
func applyStyleSpec(spec *styleSpec, rows, cols int, toolArgs map[string]any) error {
	if rows <= 0 || cols <= 0 {
		return fmt.Errorf("range 行列数必须大于 0")
	}
	if rows > 1000 {
		return fmt.Errorf("单次样式更新行数上限为 1000（当前 %d 行）", rows)
	}
	if rows*cols > 30000 {
		return fmt.Errorf("单次样式更新单元格总数上限为 30000（当前 %d×%d=%d）", rows, cols, rows*cols)
	}
	if err := apply2DString(spec.BgColor, spec.BgColorsJSON, rows, cols, "bg-color", "backgroundColors", nil, toolArgs); err != nil {
		return err
	}
	if err := applyFontSize(spec, rows, cols, toolArgs); err != nil {
		return err
	}
	if err := apply2DString(spec.HAlign, spec.HAlignsJSON, rows, cols, "h-align", "horizontalAlignments", hAlignEnum, toolArgs); err != nil {
		return err
	}
	if err := apply2DString(spec.VAlign, spec.VAlignsJSON, rows, cols, "v-align", "verticalAlignments", vAlignEnum, toolArgs); err != nil {
		return err
	}
	if err := apply2DString(spec.FontColor, spec.FontColorsJSON, rows, cols, "font-color", "fontColors", nil, toolArgs); err != nil {
		return err
	}
	if err := apply2DString(spec.FontWeight, spec.FontWeightsJSON, rows, cols, "font-weight", "fontWeights", fontWeightEnum, toolArgs); err != nil {
		return err
	}
	if spec.WordWrap != "" {
		if !wordWrapEnum[spec.WordWrap] {
			return fmt.Errorf("--word-wrap 枚举非法: %s（合法值: overflow / clip / autoWrap）", spec.WordWrap)
		}
		toolArgs["wordWrap"] = spec.WordWrap
	}
	if spec.NumberFormat != "" {
		toolArgs["numberFormat"] = spec.NumberFormat
	}
	for _, k := range []string{"backgroundColors", "fontSizes", "horizontalAlignments", "verticalAlignments", "fontColors", "fontWeights", "wordWrap", "numberFormat"} {
		if _, ok := toolArgs[k]; ok {
			return nil
		}
	}
	return fmt.Errorf("至少需要指定一个样式参数（--bg-color / --font-size / --h-align / --v-align / --font-color / --font-weight / --word-wrap / --number-format 或对应的 *-json 形式）")
}

func applyFontSize(spec *styleSpec, rows, cols int, toolArgs map[string]any) error {
	if spec.FontSize != 0 && spec.FontSizesJSON != "" {
		return fmt.Errorf("--font-size 与 --font-sizes-json 不能同时指定")
	}
	if spec.FontSize != 0 {
		if spec.FontSize < 0 {
			return fmt.Errorf("--font-size 必须为正整数")
		}
		toolArgs["fontSizes"] = fillIntMatrix(rows, cols, spec.FontSize)
		return nil
	}
	if spec.FontSizesJSON != "" {
		var m [][]int
		if err := json.Unmarshal([]byte(spec.FontSizesJSON), &m); err != nil {
			return fmt.Errorf("--font-sizes-json 解析失败: %w", err)
		}
		if err := checkMatrixShape(len(m), maxColLen2D(m), rows, cols, "font-sizes-json"); err != nil {
			return err
		}
		toolArgs["fontSizes"] = m
	}
	return nil
}

// apply2DString 处理一组 scalar + *-json 样式 flag，含枚举校验。传 enum=nil 跳过枚举校验。
func apply2DString(scalar, jsonStr string, rows, cols int, flagName, toolKey string, enum map[string]bool, toolArgs map[string]any) error {
	if scalar != "" && jsonStr != "" {
		return fmt.Errorf("--%s 与 --%s-json 不能同时指定", flagName, flagName)
	}
	if scalar != "" {
		if enum != nil && !enum[scalar] {
			return fmt.Errorf("--%s 枚举非法: %s", flagName, scalar)
		}
		toolArgs[toolKey] = fillStringMatrix(rows, cols, scalar)
		return nil
	}
	if jsonStr == "" {
		return nil
	}
	var m [][]string
	if err := json.Unmarshal([]byte(jsonStr), &m); err != nil {
		return fmt.Errorf("--%s-json 解析失败: %w", flagName, err)
	}
	if err := checkMatrixShape(len(m), maxColLenStr(m), rows, cols, flagName+"-json"); err != nil {
		return err
	}
	if enum != nil {
		for _, row := range m {
			for _, v := range row {
				if v == "" {
					continue
				}
				if !enum[v] {
					return fmt.Errorf("--%s-json 包含非法枚举值: %s", flagName, v)
				}
			}
		}
	}
	toolArgs[toolKey] = m
	return nil
}

func maxColLenStr(m [][]string) int {
	max := 0
	for _, row := range m {
		if len(row) > max {
			max = len(row)
		}
	}
	return max
}

func maxColLen2D(m [][]int) int {
	max := 0
	for _, row := range m {
		if len(row) > max {
			max = len(row)
		}
	}
	return max
}

func checkMatrixShape(gotRows, gotCols, wantRows, wantCols int, flagName string) error {
	if gotRows != wantRows || gotCols != wantCols {
		return fmt.Errorf("--%s 维度与 range 不一致：期望 %d×%d，实际 %d×%d", flagName, wantRows, wantCols, gotRows, gotCols)
	}
	return nil
}

// readStyleSpecFromFlags 从 cobra flag 读取样式参数。
func readStyleSpecFromFlags(cmd *cobra.Command) *styleSpec {
	spec := &styleSpec{}
	spec.BgColor, _ = cmd.Flags().GetString("bg-color")
	spec.BgColorsJSON, _ = cmd.Flags().GetString("bg-colors-json")
	spec.FontSize, _ = cmd.Flags().GetInt("font-size")
	spec.FontSizesJSON, _ = cmd.Flags().GetString("font-sizes-json")
	spec.HAlign, _ = cmd.Flags().GetString("h-align")
	spec.HAlignsJSON, _ = cmd.Flags().GetString("h-aligns-json")
	spec.VAlign, _ = cmd.Flags().GetString("v-align")
	spec.VAlignsJSON, _ = cmd.Flags().GetString("v-aligns-json")
	spec.FontColor, _ = cmd.Flags().GetString("font-color")
	spec.FontColorsJSON, _ = cmd.Flags().GetString("font-colors-json")
	spec.FontWeight, _ = cmd.Flags().GetString("font-weight")
	spec.FontWeightsJSON, _ = cmd.Flags().GetString("font-weights-json")
	spec.WordWrap, _ = cmd.Flags().GetString("word-wrap")
	spec.NumberFormat, _ = cmd.Flags().GetString("number-format")
	return spec
}

// bindStyleFlags 绑定共用的样式 flag。
func bindStyleFlags(cmd *cobra.Command) {
	cmd.Flags().String("bg-color", "", "背景色（#RRGGBB），一键刷整个 range；与 --bg-colors-json 二选一")
	cmd.Flags().String("bg-colors-json", "", "背景色二维 JSON 数组，维度需与 --range 一致")
	cmd.Flags().Int("font-size", 0, "字号，一键刷整个 range；与 --font-sizes-json 二选一")
	cmd.Flags().String("font-sizes-json", "", "字号二维 JSON 数组，维度需与 --range 一致")
	cmd.Flags().String("h-align", "", "水平对齐（left/center/right/general），一键刷整个 range")
	cmd.Flags().String("h-aligns-json", "", "水平对齐二维 JSON 数组")
	cmd.Flags().String("v-align", "", "垂直对齐（top/middle/bottom），一键刷整个 range")
	cmd.Flags().String("v-aligns-json", "", "垂直对齐二维 JSON 数组")
	cmd.Flags().String("font-color", "", "字体颜色（#RRGGBB），一键刷整个 range")
	cmd.Flags().String("font-colors-json", "", "字体颜色二维 JSON 数组")
	cmd.Flags().String("font-weight", "", "字体粗细（bold/normal），一键刷整个 range")
	cmd.Flags().String("font-weights-json", "", "字体粗细二维 JSON 数组")
	cmd.Flags().String("word-wrap", "", "换行方式（overflow/clip/autoWrap），整个 range 共用")
	cmd.Flags().String("number-format", "", "数字格式 code（常用 General/@/#,##0/#,##0.00/0%/0.00%/yyyy/m/d/h:mm:ss；@ 为文本，适合长数字 ID）")
}

// newRangeSetStyleCmd 构造 dws sheet range set-style 命令。
func newRangeSetStyleCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "set-style",
		Short: "设置指定单元格区域的样式",
		Long: `通过 update_range 透传样式字段，为指定 range 设置背景色 / 字号 / 对齐 / 字体颜色 / 字体粗细 / 换行方式 / 数字格式。

每个样式维度提供两种用法，二选一：
  --xxx             单值，一键刷整个 range（由 CLI 本地展开为二维数组）
  --xxx-json        二维 JSON 数组，逐单元格指定，维度需与 --range 一致

单次调用建议：行数 ≤ 1000 且行×列 ≤ 5000；服务端硬限 rows ≤ 1000 且 rows×cols ≤ 30000。

数字格式（--number-format）传格式 code：
  General 常规；@ 文本；0/0.00 普通数字；#,##0/#,##0.00 千分位；0%/0.00% 百分比；yyyy/m/d 日期；h:mm/h:mm:ss 时间；0.00E+00/##0.0E+0 科学计数；货币格式如 "¥"#,##0.00 或 $#,##0.00。
  商品ID、规格ID、订单号、手机号等数字形态标识符请设置 @，否则 General/默认展示可能转为科学计数法。
传入格式 code 字符串。`,
		Example: `  # 给 A1:B3 打上黄底粗体居中
  dws sheet range set-style --node NODE_ID --sheet-id SHEET_ID --range "A1:B3" \
    --bg-color "#FFF2CC" --font-weight bold --h-align center

  # 给 C1:C5 逐单元格设置不同背景色
  dws sheet range set-style --node NODE_ID --sheet-id SHEET_ID --range "C1:C5" \
    --bg-colors-json '[["#FF0000"],["#00FF00"],["#0000FF"],["#FFFF00"],["#FF00FF"]]'

  # 整片 range 启用自动换行
  dws sheet range set-style --node NODE_ID --sheet-id SHEET_ID --range "A1:E10" --word-wrap autoWrap

  # 长数字标识符按文本展示，避免科学计数法
  dws sheet range set-style --node NODE_ID --sheet-id SHEET_ID --range "A2:A100" --number-format "@"`,
		RunE: func(cmd *cobra.Command, args []string) error {
			if err := validateRequiredFlags(cmd, "node", "sheet-id", "range"); err != nil {
				return err
			}
			node := mustGetFlag(cmd, "node")
			sheetID := mustGetFlag(cmd, "sheet-id")
			rangeAddr := mustGetFlag(cmd, "range")

			rows, cols, err := parseA1Range(rangeAddr)
			if err != nil {
				return err
			}
			toolArgs := map[string]any{
				"nodeId":       node,
				"sheetId":      sheetID,
				"rangeAddress": rangeAddr,
			}
			spec := readStyleSpecFromFlags(cmd)
			if err := applyStyleSpec(spec, rows, cols, toolArgs); err != nil {
				return err
			}
			return callMCPTool("update_range", toolArgs)
		},
	}
	cmd.Flags().String("node", "", "表格文档 ID 或 URL (必填)")
	cmd.Flags().String("sheet-id", "", "工作表 ID 或名称 (必填)")
	cmd.Flags().String("range", "", "目标单元格区域地址，如 A1:B3 (必填)")
	bindStyleFlags(cmd)
	return cmd
}

// newRangeBatchSetStyleCmd 构造 dws sheet range batch-set-style 命令（方案 A：CLI 侧顺序循环）。
func newRangeBatchSetStyleCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "batch-set-style",
		Short: "按配置文件批量设置样式",
		Long: `读取一份 JSON 配置，逐条调用 update_range 给不同 range 设置样式，CLI 内部顺序执行。

配置格式（JSON 数组，每个元素为一个批次项）：
[
  {
    "sheetId": "Sheet1",
    "range":   "A1:B3",
    "bgColor":    "#FFF2CC",
    "fontSize":   12,
    "hAlign":     "center",
    "vAlign":     "middle",
    "fontColor":  "#333333",
    "fontWeight": "bold",
    "wordWrap":   "autoWrap",
    "numberFormat": "General"
  },
  {
    "sheetId": "Sheet1",
    "range":   "C1:C5",
    "bgColorsJson": "[[\"#FF0000\"],[\"#00FF00\"],[\"#0000FF\"],[\"#FFFF00\"],[\"#FF00FF\"]]"
  }
]

每条记录执行与 set-style 一致的校验（至少一项样式字段 + rows≤1000 + rows×cols≤30000 + 枚举）。
某条失败时默认停止后续批次；要继续执行请加 --continue-on-error。`,
		Example: `  dws sheet range batch-set-style --node NODE_ID --batch ./styles.json
  dws sheet range batch-set-style --node NODE_ID --batch ./styles.json --continue-on-error`,
		RunE: func(cmd *cobra.Command, args []string) error {
			if err := validateRequiredFlags(cmd, "node", "batch"); err != nil {
				return err
			}
			node := mustGetFlag(cmd, "node")
			batchPath := mustGetFlag(cmd, "batch")
			continueOnErr, _ := cmd.Flags().GetBool("continue-on-error")
			jsonMode := deps.Caller.Format() == "json"
			ctx := context.Background()
			var jsonResults []any

			data, err := os.ReadFile(batchPath)
			if err != nil {
				return fmt.Errorf("读取 --batch 文件失败: %w", err)
			}
			var items []batchItem
			if err := json.Unmarshal(data, &items); err != nil {
				return fmt.Errorf("--batch JSON 解析失败: %w", err)
			}
			if len(items) == 0 {
				return fmt.Errorf("--batch 配置为空")
			}

			total := len(items)
			var firstErr error
			var failed int
			for i, item := range items {
				if item.SheetID == "" || item.Range == "" {
					err := fmt.Errorf("第 %d/%d 条缺少 sheetId 或 range", i+1, total)
					fmt.Fprintln(os.Stderr, err)
					failed++
					if firstErr == nil {
						firstErr = err
					}
					if !continueOnErr {
						break
					}
					continue
				}
				rows, cols, err := parseA1Range(item.Range)
				if err != nil {
					err = fmt.Errorf("第 %d/%d 条 range 解析失败: %w", i+1, total, err)
					fmt.Fprintln(os.Stderr, err)
					failed++
					if firstErr == nil {
						firstErr = err
					}
					if !continueOnErr {
						break
					}
					continue
				}
				toolArgs := map[string]any{
					"nodeId":       node,
					"sheetId":      item.SheetID,
					"rangeAddress": item.Range,
				}
				if err := applyStyleSpec(&item.styleSpec, rows, cols, toolArgs); err != nil {
					err = fmt.Errorf("第 %d/%d 条样式校验失败: %w", i+1, total, err)
					fmt.Fprintln(os.Stderr, err)
					failed++
					if firstErr == nil {
						firstErr = err
					}
					if !continueOnErr {
						break
					}
					continue
				}
				fmt.Fprintf(os.Stderr, "[%d/%d] update_range sheet=%s range=%s\n", i+1, total, item.SheetID, item.Range)
				if deps.Caller.DryRun() {
					// JSON mode emits one aggregate preview below. Human formats
					// reuse the shared per-call preview printer.
					if !jsonMode {
						_ = callMCPTool("update_range", toolArgs)
					}
					if jsonMode {
						jsonResults = append(jsonResults, map[string]any{
							"index":     i + 1,
							"sheetId":   item.SheetID,
							"range":     item.Range,
							"ok":        true,
							"dryRun":    true,
							"tool":      "update_range",
							"arguments": toolArgs,
						})
					}
					continue
				}
				if jsonMode {
					text, cerr := callMCPToolReturnText(ctx, "update_range", toolArgs)
					entry := map[string]any{"index": i + 1, "sheetId": item.SheetID, "range": item.Range}
					if cerr != nil {
						entry["ok"] = false
						entry["error"] = cerr.Error()
						jsonResults = append(jsonResults, entry)
						cerr = fmt.Errorf("第 %d/%d 条 update_range 失败: %w", i+1, total, cerr)
						fmt.Fprintln(os.Stderr, cerr)
						failed++
						if firstErr == nil {
							firstErr = cerr
						}
						if !continueOnErr {
							break
						}
						continue
					}
					var parsed any
					if json.Unmarshal([]byte(text), &parsed) == nil {
						entry["result"] = parsed
					} else {
						entry["result"] = text
					}
					entry["ok"] = true
					jsonResults = append(jsonResults, entry)
					continue
				}
				if err := callMCPTool("update_range", toolArgs); err != nil {
					err = fmt.Errorf("第 %d/%d 条 update_range 失败: %w", i+1, total, err)
					fmt.Fprintln(os.Stderr, err)
					failed++
					if firstErr == nil {
						firstErr = err
					}
					if !continueOnErr {
						break
					}
				}
			}
			fmt.Fprintf(os.Stderr, "batch-set-style 完成：共 %d 条，失败 %d 条\n", total, failed)
			if jsonMode {
				if err := deps.Out.PrintJSON(map[string]any{
					"total":   total,
					"failed":  failed,
					"results": jsonResults,
					"success": failed == 0,
				}); err != nil {
					return err
				}
			}
			if failed > 0 && !continueOnErr {
				return firstErr
			}
			if failed > 0 {
				return fmt.Errorf("batch-set-style 共 %d 条失败（首个错误：%v）", failed, firstErr)
			}
			return nil
		},
	}
	cmd.Flags().String("node", "", "表格文档 ID 或 URL (必填)")
	cmd.Flags().String("batch", "", "批次配置 JSON 文件路径 (必填)")
	cmd.Flags().Bool("continue-on-error", false, "遇到失败时继续执行后续条目（默认遇错即停）")
	return cmd
}