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 '@/hooks/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 = () => {
    const values = form.getFieldsValue()
    post(
      {
        response_format: { type: 'json_object' },
        messages: [
          {
            role: 'user',
            content: `根据提供的数据集，设计一个层次聚类算法，返回JSON格式。
          自变量：${values.independent_variables.join(', ')}
          因变量：${values.dependent_variable}
          分别返回是否拟合截距项（fit_intercept）:true/false、是否复制数据（copy_x）:true/false、并行计算核心数（n_jobs）:None（单线程）或 ≥1 的整数（如 -1 表示使用所有核心）、强制正系数（positive）:true/false的值。
返回格式示例：
json
        {
          "results": { "fit_intercept": true, "copy_x": true, "n_jobs": 1, "positive": false}
        }
          `,
          },
        ],
      },
      {
        onComplete: (message) => {
          console.log(message)
          try {
            const parse = JSON.parse(message.content)
            form.setFieldsValue(parse.results)
          } catch (error) {
            console.error(error)
          }
        },
      }
    )
  }

  // AI计算
  const [results, setResults] = useState<any>({})
  const code = `${results.code?.replace(/\\n/gi, '\n')}`
  const [openResults, setOpenResults] = useState(false)
  const handleAICompute = () => {
    const values = form.getFieldsValue()
    post(
      {
        response_format: { type: 'json_object' },
        messages: [
          {
            role: 'user',
            content: `根据提供的数据集，设置的层次聚类算法进行试算检查，返回JSON格式。
          自变量：${values.independent_variables.join(', ')}
          因变量：${values.dependent_variable}
          是否拟合截距项（fit_intercept）：${values.fit_intercept}
          是否复制数据（copy_X）：${values.copy_x}
          并行计算核心数（n_jobs）：${values.n_jobs}
          强制正系数（positive）：${values.positive}
          返回格式示例：
          json
          {
           results: { pass: 'true或者false，代表通过不通过', code: "Python运行的代码，markdown能解析的代码", result: "计算结果" },
          }
           `,
          },
        ],
      },
      {
        onComplete: (message) => {
          console.log(message)
          try {
            const parse = JSON.parse(message.content)
            setResults(parse.results)
          } catch (error) {
            console.error(error)
          }
          if (current === 1) {
            setStep(3)
          }
        },
      }
    )
  }

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

  const options = [
    { label: 'True', value: true },
    { label: 'False', value: false },
  ]

  // 处理下一步按钮逻辑
  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="请输入连接方法（linkage）">
                <Flex gap={10}>
                  <Form.Item name="fit_intercept" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Select
                      options={[
                        { label: 'single', value: 'single' },
                        { label: 'complete', value: 'complete' },
                        { label: 'ward', value: 'ward' },
                        { label: 'average', value: 'average' },
                      ]}
                      placeholder="请选择"
                    />
                  </Form.Item>
                  <Popover
                    title="连接方法（linkage）"
                    content={
                      <>
                        定义簇间距离的计算方式（影响树形结构生成） <br />
                        取值范围：'ward', 'complete', 'average', 'single' <br />
                        'single'（最小距离）：易形成链式簇 <br />
                        'complete'（最大距离）：生成紧凑簇 <br />
                        'ward'（方差最小化）：需配合欧氏距离 <br />
                        'average'（平均距离）：平衡灵敏度
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入距离度量（affinity 或 metric）">
                <Flex gap={10}>
                  <Form.Item name="affinity" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Select
                      options={[
                        { label: 'euclidean', value: 'euclidean' },
                        { label: 'cosine', value: 'cosine' },
                        { label: 'manhattan', value: 'manhattan' },
                      ]}
                      placeholder="请选择"
                    />
                  </Form.Item>
                  <Popover
                    title="距离度量（affinity 或 metric）"
                    content={
                      <>
                        定义样本间距离的计算方法（需与linkage方法兼容） <br />
                        取值范围：'euclidean', 'cosine', 'manhattan' <br />
                        'cosine'适合高维稀疏数据 <br />
                        'manhattan'对异常值更鲁棒 <br />
                        'euclidean'默认适用于连续特征，但需特征标准化
                        <br />
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入并行计算核心数（n_jobs）">
                <Flex gap={10}>
                  <Form.Item name="n_jobs" noStyle rules={[{ required: true, message: '请输入' }]}>
                    <Input placeholder="请输入" />
                  </Form.Item>
                  <Popover
                    title="并行计算核心数（n_jobs）"
                    content={
                      <>
                        选择优化算法（不同算法支持不同正则化类型和计算效率）
                        <br />
                        取值范围：
                        <br />
                        None（单线程）或 ≥1 的整数（如 -1 表示使用所有核心）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入计算完整树形（compute_full_tree）">
                <Flex gap={10}>
                  <Form.Item name="compute_full_tree" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Select options={options} placeholder="请选择" />
                  </Form.Item>
                  <Popover
                    title="计算完整树形（compute_full_tree）"
                    content={
                      <>
                        是否预先计算完整树形结构（当使用distance_threshold时自动启用） <br />
                        取值范围：'auto', True, False <br />
                        False时可能节省内存（但无法回溯完整层次结构） <br />
                        True保证完整树形（内存消耗随样本数平方增长）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
              <Form.Item label="请输入距离阈值（distance_threshold）">
                <Flex gap={10}>
                  <Form.Item name="distance_threshold" noStyle rules={[{ required: true, message: '请选择' }]}>
                    <Input placeholder="请选择" />
                  </Form.Item>
                  <Popover
                    title="距离阈值（distance_threshold）"
                    content={
                      <>
                        定义簇合并停止的截断距离（若设置则n_clusters无效） <br />
                        取值范围：≥0（根据距离度量类型调整，如欧氏距离≥0，余弦相似度∈[0,2]） <br />
                        参数越低意味着允许更大距离的簇合并（簇更少、更粗粒度），参数越高意味着仅允许小距离的簇合并（簇更多、更细粒度）
                      </>
                    }>
                    <QuestionCircleOutlined />
                  </Popover>
                </Flex>
              </Form.Item>
            </div>
            <Button type="primary" style={{ height: '250px' }} onClick={handleAISet} loading={isLoading}>
              AI设置
            </Button>
          </Flex>
        </>
      ),
    },
    {
      title: '层次聚类处理',
      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={() => {
              setOpenResults(true)
              handleAICompute()
            }}
            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)}>
        层次聚类
      </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>
          {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>
    </>
  )
}
