import { useState } from 'react'
import { Button, Flex, Modal, Select, Form, Input, Popover, Card } from 'antd'
import { QuestionCircleOutlined } from '@ant-design/icons'
import AppProgressSteps from '@/components/AppProgressSteps'
import { useDataFieldQuery } from '@/hooks/useQuery'
import { useAI } from '@/ai/useAI'
import MarkdownRender from '@/components/MarkdownRender'

export default function ButtonModal() {
  const { fieldOptions } = useDataFieldQuery()

  const [open, setOpen] = useState(false)
  const [current, setCurrent] = useState(0)
  const [form] = Form.useForm()

  const { post, isLoading } = useAI()

  // AI设置
  const handleAISet = async () => {
    await form.validateFields(['independent_variables'])

    const values = form.getFieldsValue()
    const message = await post({
      response_format: { type: 'json_object' },
      messages: [
        {
          role: 'user',
          content: `根据提供的数据集，设计一个K-Means算法，返回JSON格式。
          特征列：${values.independent_variables?.join(', ')}
返回格式示例：
json
        {
          "results": { "n_clusters": "簇数量（n_clusters）", "init": "初始化方法（init）", "n_init": "初始化次数（n_init）", "max_iter": "最大迭代次数（max_iter）", "tol": "收敛阈值（tol）", "random_state": "随机种子（random_state）", "algorithm": "算法实现（algorithm）" }
        }
          `,
        },
      ],
    })
    if (message.json && message.json.results) {
      form.setFieldsValue(message.json.results)
    }
  }

  // AI计算
  const [results, setResults] = useState<any>({})
  const code = `${results.code?.replace(/\\n/gi, '\n')}`
  const [openResults, setOpenResults] = useState(false)
  const handleAICompute = async () => {
    const values = await form.validateFields()
    const message = await post({
      response_format: { type: 'json_object' },
      messages: [
        {
          role: 'user',
          content: `根据提供的数据集，设置的K-Means算法进行试算检查，返回JSON格式。
          特征列${values.independent_variables?.join(', ')}
          簇数量（n_clusters）：${values.n_clusters}
          初始化方法（init）：${values.init}
          初始化次数（n_init）：${values.n_init}
          最大迭代次数（max_iter）：${values.max_iter}
          收敛阈值（tol）：${values.tol}
          随机种子（random_state）：${values.random_state}
          算法实现（algorithm：${values.algorithm}
          返回格式示例：
          json
          {
           results: { pass: 'true或者false，代表通过不通过', code: "Python运行的代码，markdown能解析的代码", result: "计算结果" },
          }
           `,
        },
      ],
    })
    if (message.json && message.json.results) {
      setResults(message.json.results)
    }
    if (current === 1) {
      setStep(3)
    }
  }

  const [step, setStep] = useState<number>(-1)

  // 处理下一步按钮逻辑
  const handleNext = async () => {
    await form.validateFields()
    setCurrent(current + 1)
    setStep(-1)
  }

  // 开始处理
  const handleStart = () => {
    setStep(1)
    handleAICompute()
  }

  // 关闭并重置
  const handleClose = () => {
    setOpen(false)
    setCurrent(0)
    setStep(-1)
  }

  const steps = [
    {
      title: '设置算法',
      content: (
        <>
          <Form.Item label="请选择特征列" name="independent_variables" rules={[{ required: true, message: '请选择' }]}>
            <Select options={fieldOptions} placeholder="请选择" mode="multiple" />
          </Form.Item>

          <Flex gap={20}>
            <div style={{ flex: 1 }}>
              <Form.Item label="请输入簇数量（n_clusters）">
                <Flex gap={10}>
                  <Form.Item name="n_clusters" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="是否拟合截距项（fit_intercept）"
                    content={
                      <>
                        控制模型是否包含截距项（即偏置项，用于调整模型基线）
                        <br />
                        取值范围：
                        <br />
                        True（模型更灵活，适合大多数场景）
                        <br />
                        False（模型强制通过原点，可能欠拟合）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入初始化方法（init）">
                <Flex gap={10}>
                  <Form.Item name="init" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="初始化方法init"
                    content={
                      <>
                        定义初始簇中心的生成方式（影响收敛速度和结果质量）
                        <br />
                        取值范围：'k-means++', 'random', 或自定义数组
                        <br />
                        随机初始化（'random'）可能导致不稳定结果，'k-means++' 更智能选择初始点（加速收敛，提高稳定性）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入初始化次数（n_init）">
                <Flex gap={10}>
                  <Form.Item name="n_init" noStyle rules={[{ required: true, message: '请输入' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="初始化次数n_init"
                    content={
                      <>
                        算法以不同初始中心运行的次数（避免局部最优解） <br />
                        取值范围：≥1 <br />
                        参数越低意味着减少计算次数（结果可能不稳定，但速度快），参数越高意味着增加结果稳定性（计算成本更高）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入最大迭代次数（max_iter）">
                <Flex gap={10}>
                  <Form.Item name="max_iter" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="最大迭代次数max_iter"
                    content={
                      <>
                        单次运行中的最大迭代次数（防止无限循环）
                        <br />
                        取值范围：≥1
                        <br />
                        参数越低意味着提前终止迭代（可能未收敛，但节省时间），参数越高意味着允许更多迭代（更可能收敛到最优解，但耗时增加）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入收敛阈值（tol）">
                <Flex gap={10}>
                  <Form.Item name="tol" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="收敛阈值tol"
                    content={
                      <>
                        两次迭代间簇中心变化的阈值，低于此值则停止迭代 <br />
                        取值范围：≥0 <br />
                        参数越低意味着更宽松的收敛条件（提前停止，可能牺牲精度），参数越高意味着更严格的收敛条件（需更多迭代，结果更精确）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入随机种子（random_state）">
                <Flex gap={10}>
                  <Form.Item name="random_state" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="随机种子random_state"
                    content={
                      <>
                        控制初始中心选择的随机性（确保结果可复现）
                        <br />
                        取值范围：整数或None
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入算法实现（algorithm）">
                <Flex gap={10}>
                  <Form.Item name="algorithm" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="算法实现algorithm"
                    content={
                      <>
                        选择K-Means的计算实现方式（针对效率优化） <br />
                        取值范围：'auto', 'full', 'elkan'
                        <br />
                        'elkan'适用于稠密数据但内存占用高，'full'适用于稀疏数据，'auto'自动根据数据稀疏性选择最优实现
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
            </div>
            <Button type="primary" style={{ height: '360px' }} onClick={handleAISet} loading={isLoading}>
              AI设置
            </Button>
          </Flex>
        </>
      ),
    },
    {
      title: 'K-Means处理',
      content: (
        <>
          <Flex vertical align="center" style={{ marginTop: '20px' }}>
            <Button type="primary" onClick={handleStart} loading={isLoading}>
              开始处理
            </Button>
            <AppProgressSteps current={step} items={[{ title: '启动' }, { title: '计算' }, { title: '计算结束' }]} />
          </Flex>
        </>
      ),
    },
  ]

  const Footer = () => {
    return (
      <Flex justify="center" gap={20}>
        {current === 0 && (
          <Button
            type="primary"
            onClick={async () => {
              await handleAICompute()
              setOpenResults(true)
            }}
            loading={isLoading}>
            AI检查试算
          </Button>
        )}
        {current > 0 && <Button onClick={() => setCurrent(current - 1)}>上一步</Button>}
        {current < steps.length - 1 && (
          <Button type="primary" onClick={handleNext}>
            下一步
          </Button>
        )}
        {current === steps.length - 1 && (
          <Button type="primary" onClick={handleClose} disabled={isLoading}>
            关闭
          </Button>
        )}
      </Flex>
    )
  }

  return (
    <>
      <Button type="primary" onClick={() => setOpen(true)}>
        K-Means
      </Button>
      <Modal
        title={steps[current].title}
        open={open}
        footer={<Footer />}
        destroyOnClose
        width={800}
        onCancel={handleClose}>
        <div style={{ minHeight: 300, padding: '20px 0' }}>
          <Form form={form} preserve={false}>
            {steps.map((item, index) => (
              <div key={index} hidden={current !== index} style={{ marginTop: '20px' }}>
                {item.content}
              </div>
            ))}
          </Form>
          {current === 1 && step >= 3 && (
            <Card style={{ marginTop: '20px' }}>
              <p>计算结束！</p>
              <p>计算结果如下：</p>
              {results.result}
            </Card>
          )}
        </div>
      </Modal>
      <Modal
        title="算法试算检查"
        open={openResults}
        footer={null}
        width={800}
        loading={isLoading}
        onCancel={() => setOpenResults(false)}>
        <p style={{ fontSize: 20, textAlign: 'center' }}>试算检查结果：{results.pass ? '通过' : '不通过'}！</p>
        <MarkdownRender>{code}</MarkdownRender>
      </Modal>
    </>
  )
}
