import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import {
  Button, Card, Col, Input, InputNumber, message, Row, Segmented, Space, Statistic, Switch, Table, Tag, Typography,
} from 'antd';
import type { TableProps } from 'antd';
import { DownloadOutlined, PlayCircleOutlined, ReloadOutlined, StopOutlined } from '@ant-design/icons';
import { huyaApi, type HuyaAutoRegisterBatch, type HuyaAutoRegisterItem } from '../api/modules';
import { formatTime } from '../utils/time';
import { getErrorMessage } from '../utils/error';

const { TextArea } = Input;
const { Text, Title } = Typography;

type PasswordMode = 'random' | 'fixed';

interface StoredRegisterForm {
  text: string;
  tag: string;
  concurrency: number;
  waitSeconds: number;
  pollInterval: number;
  passwordMode: PasswordMode;
  passwordPrefix: string;
  fixedPassword: string;
  useProxy: boolean;
}

const FORM_STORAGE_KEY = 'huya_auto_register_form';
const BATCH_STORAGE_KEY = 'huya_auto_register_batch_id';
const DEFAULT_FORM: StoredRegisterForm = {
  text: '',
  tag: '',
  concurrency: 1,
  waitSeconds: 180,
  pollInterval: 5,
  passwordMode: 'random',
  passwordPrefix: 'hy',
  fixedPassword: '',
  useProxy: false,
};

const STATUS_LABELS: Record<string, string> = {
  pending: '等待',
  sending: '发码',
  waiting: '等待验证码',
  logging: '保存',
  changing: '改密',
  success: '成功',
  error: '失败',
  stopped: '已停止',
};

const STATUS_COLORS: Record<string, string> = {
  pending: 'default',
  sending: 'processing',
  waiting: 'processing',
  logging: 'processing',
  changing: 'processing',
  success: 'success',
  error: 'error',
  stopped: 'warning',
};

const RUNNING_STATUS = new Set(['pending', 'running']);

function safeNumber(value: unknown, fallback: number) {
  const n = Number(value);
  return Number.isFinite(n) ? n : fallback;
}

function readStoredForm(): StoredRegisterForm {
  try {
    const raw = localStorage.getItem(FORM_STORAGE_KEY);
    if (!raw) return DEFAULT_FORM;
    const parsed = JSON.parse(raw) as Partial<StoredRegisterForm>;
    const passwordMode = parsed.passwordMode === 'fixed' ? 'fixed' : 'random';
    return {
      ...DEFAULT_FORM,
      ...parsed,
      concurrency: safeNumber(parsed.concurrency, DEFAULT_FORM.concurrency),
      waitSeconds: safeNumber(parsed.waitSeconds, DEFAULT_FORM.waitSeconds),
      pollInterval: safeNumber(parsed.pollInterval, DEFAULT_FORM.pollInterval),
      passwordMode,
      useProxy: Boolean(parsed.useProxy),
    };
  } catch {
    return DEFAULT_FORM;
  }
}

function readStoredBatchId() {
  try {
    return localStorage.getItem(BATCH_STORAGE_KEY) || '';
  } catch {
    return '';
  }
}

export default function HuyaRegisterPage() {
  const initialFormRef = useRef<StoredRegisterForm | null>(null);
  if (initialFormRef.current === null) {
    initialFormRef.current = readStoredForm();
  }
  const initialForm = initialFormRef.current;

  const [text, setText] = useState(initialForm.text);
  const [tag, setTag] = useState(initialForm.tag);
  const [concurrency, setConcurrency] = useState(initialForm.concurrency);
  const [waitSeconds, setWaitSeconds] = useState(initialForm.waitSeconds);
  const [pollInterval, setPollInterval] = useState(initialForm.pollInterval);
  const [passwordMode, setPasswordMode] = useState<PasswordMode>(initialForm.passwordMode);
  const [passwordPrefix, setPasswordPrefix] = useState(initialForm.passwordPrefix);
  const [fixedPassword, setFixedPassword] = useState(initialForm.fixedPassword);
  const [useProxy, setUseProxy] = useState(initialForm.useProxy);
  const [batch, setBatch] = useState<HuyaAutoRegisterBatch | null>(null);
  const [starting, setStarting] = useState(false);
  const [refreshing, setRefreshing] = useState(false);
  const [stopping, setStopping] = useState(false);
  const restoredBatchRef = useRef(false);

  const batchId = batch?.batch_id || '';
  const isRunning = !!batch && RUNNING_STATUS.has(batch.status);

  const loadBatchById = useCallback(async (id: string) => {
    if (!id) return;
    setRefreshing(true);
    try {
      const data = await huyaApi.getAutoRegisterBatch(id);
      setBatch(data);
      localStorage.setItem(BATCH_STORAGE_KEY, data.batch_id);
    } catch (e: unknown) {
      const err = getErrorMessage(e);
      if (err.includes('批次不存在') || err.includes('服务已重启')) {
        localStorage.removeItem(BATCH_STORAGE_KEY);
        setBatch(null);
        message.warning('上次自动注册批次已不存在，已清除恢复记录');
      } else {
        message.error(err);
      }
    } finally {
      setRefreshing(false);
    }
  }, []);

  const refreshBatch = useCallback(async () => {
    if (!batchId) return;
    await loadBatchById(batchId);
  }, [batchId, loadBatchById]);

  useEffect(() => {
    localStorage.setItem(FORM_STORAGE_KEY, JSON.stringify({
      text,
      tag,
      concurrency,
      waitSeconds,
      pollInterval,
      passwordMode,
      passwordPrefix,
      fixedPassword,
      useProxy,
    }));
  }, [text, tag, concurrency, waitSeconds, pollInterval, passwordMode, passwordPrefix, fixedPassword, useProxy]);

  useEffect(() => {
    if (restoredBatchRef.current) return;
    restoredBatchRef.current = true;
    const storedBatchId = readStoredBatchId();
    if (storedBatchId) {
      loadBatchById(storedBatchId);
    }
  }, [loadBatchById]);

  useEffect(() => {
    if (batch?.batch_id) {
      localStorage.setItem(BATCH_STORAGE_KEY, batch.batch_id);
    }
  }, [batch?.batch_id]);

  useEffect(() => {
    if (!isRunning || !batchId) return undefined;
    const timer = window.setInterval(() => {
      refreshBatch();
    }, 2000);
    return () => window.clearInterval(timer);
  }, [batchId, isRunning, refreshBatch]);

  const successRows = useMemo(
    () => (batch?.items || []).filter((item) => item.status === 'success' && item.password && (item.username || item.uid)),
    [batch],
  );

  const handleStart = async () => {
    if (!text.trim()) {
      message.warning('请先粘贴手机号池');
      return;
    }
    if (passwordMode === 'fixed' && !fixedPassword.trim()) {
      message.warning('请先填写固定密码');
      return;
    }
    setStarting(true);
    try {
      const data = await huyaApi.startAutoRegister({
        text,
        tag: tag.trim(),
        concurrency,
        wait_seconds: waitSeconds,
        poll_interval: pollInterval,
        password_prefix: passwordMode === 'random' ? (passwordPrefix.trim() || 'hy') : 'hy',
        fixed_password: passwordMode === 'fixed' ? fixedPassword.trim() : '',
        use_proxy: useProxy,
      });
      setBatch(data);
      message.success('自动注册批次已启动');
    } catch (e: unknown) {
      message.error(getErrorMessage(e));
    } finally {
      setStarting(false);
    }
  };

  const handleStop = async () => {
    if (!batchId) return;
    setStopping(true);
    try {
      const result = await huyaApi.stopAutoRegisterBatch(batchId);
      message.success(result.message);
      refreshBatch();
    } catch (e: unknown) {
      message.error(getErrorMessage(e));
    } finally {
      setStopping(false);
    }
  };

  const handleExportSuccess = () => {
    if (successRows.length === 0) {
      message.warning('当前批次没有可导出的成功账号');
      return;
    }
    const body = successRows
      .map((item) => `${item.username || item.uid}----${item.password}----${item.phone}----${item.sms_url}`)
      .join('\n');
    const blob = new Blob([body], { type: 'text/plain;charset=utf-8' });
    const url = URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;
    link.download = `huya-register-accounts-${batchId || 'success'}.txt`;
    link.click();
    URL.revokeObjectURL(url);
  };

  const columns: TableProps<HuyaAutoRegisterItem>['columns'] = [
    { title: '行', dataIndex: 'line', width: 64 },
    { title: '手机号', dataIndex: 'phone', width: 150 },
    {
      title: '虎牙号',
      width: 150,
      render: (_, item) => item.username || item.uid || '-',
    },
    {
      title: '密码',
      dataIndex: 'password',
      width: 130,
      render: (value: string) => value || '-',
    },
    { title: '平台', dataIndex: 'provider', width: 90 },
    {
      title: '状态',
      dataIndex: 'status',
      width: 110,
      render: (status: string) => (
        <Tag color={STATUS_COLORS[status] || 'default'}>
          {STATUS_LABELS[status] || status}
        </Tag>
      ),
    },
    { title: '注册码', dataIndex: 'code', width: 100 },
    { title: '改密码', dataIndex: 'change_code', width: 100 },
    {
      title: '轮询',
      width: 90,
      render: (_, item) => `${item.attempts}/${item.change_attempts}`,
    },
    {
      title: '账号',
      width: 160,
      render: (_, item) => item.uid || (item.account_id ? `#${item.account_id}` : '-'),
    },
    {
      title: '消息',
      dataIndex: 'message',
      ellipsis: true,
      render: (value: string) => value || '-',
    },
    {
      title: '完成时间',
      dataIndex: 'finished_at',
      width: 170,
      render: (value: string | null) => formatTime(value),
    },
  ];

  return (
    <Space direction="vertical" size={16} style={{ width: '100%' }}>
      <Title level={3} style={{ margin: 0 }}>虎牙自动注册</Title>

      <Card title="手机号池">
        <Space direction="vertical" size={12} style={{ width: '100%' }}>
          <TextArea
            rows={9}
            value={text}
            onChange={(event) => setText(event.target.value)}
            placeholder="手机号----短信查询URL"
            disabled={isRunning}
          />
          <Row gutter={[12, 12]}>
            <Col xs={24} md={8}>
              <Text type="secondary">标签</Text>
              <Input
                value={tag}
                onChange={(event) => setTag(event.target.value)}
                placeholder="注册批次"
                disabled={isRunning}
              />
            </Col>
            <Col xs={8} md={4}>
              <Text type="secondary">并发</Text>
              <InputNumber
                min={1}
                max={5}
                value={concurrency}
                onChange={(value) => setConcurrency(Number(value || 1))}
                disabled={isRunning}
                style={{ width: '100%' }}
              />
            </Col>
            <Col xs={8} md={4}>
              <Text type="secondary">等待秒数</Text>
              <InputNumber
                min={15}
                max={600}
                value={waitSeconds}
                onChange={(value) => setWaitSeconds(Number(value || 180))}
                disabled={isRunning}
                style={{ width: '100%' }}
              />
            </Col>
            <Col xs={8} md={4}>
              <Text type="secondary">轮询间隔</Text>
              <InputNumber
                min={1}
                max={30}
                value={pollInterval}
                onChange={(value) => setPollInterval(Number(value || 5))}
                disabled={isRunning}
                style={{ width: '100%' }}
              />
            </Col>
            <Col xs={24} md={8}>
              <Text type="secondary">密码设置</Text>
              <Space.Compact style={{ width: '100%' }}>
                <Segmented
                  value={passwordMode}
                  options={[
                    { label: '随机', value: 'random' },
                    { label: '固定', value: 'fixed' },
                  ]}
                  onChange={(value) => setPasswordMode(value as 'random' | 'fixed')}
                  disabled={isRunning}
                />
                {passwordMode === 'random' ? (
                  <Input
                    value={passwordPrefix}
                    maxLength={8}
                    onChange={(event) => setPasswordPrefix(event.target.value)}
                    disabled={isRunning}
                  />
                ) : (
                  <Input.Password
                    value={fixedPassword}
                    maxLength={64}
                    onChange={(event) => setFixedPassword(event.target.value)}
                    disabled={isRunning}
                  />
                )}
              </Space.Compact>
            </Col>
            <Col xs={12} md={4}>
              <Text type="secondary">代理</Text>
              <div style={{ height: 32, display: 'flex', alignItems: 'center' }}>
                <Switch
                  checked={useProxy}
                  checkedChildren="开"
                  unCheckedChildren="关"
                  onChange={setUseProxy}
                  disabled={isRunning}
                />
              </div>
            </Col>
            <Col xs={24} md={4}>
              <Space style={{ width: '100%', paddingTop: 22 }}>
                <Button
                  type="primary"
                  icon={<PlayCircleOutlined />}
                  loading={starting}
                  disabled={isRunning}
                  onClick={handleStart}
                >
                  开始
                </Button>
                <Button
                  danger
                  icon={<StopOutlined />}
                  loading={stopping}
                  disabled={!isRunning}
                  onClick={handleStop}
                >
                  停止
                </Button>
              </Space>
            </Col>
          </Row>
        </Space>
      </Card>

      <Card
        title="批次结果"
        extra={(
          <Space>
            <Button icon={<ReloadOutlined />} loading={refreshing} disabled={!batchId} onClick={refreshBatch}>
              刷新
            </Button>
            <Button icon={<DownloadOutlined />} disabled={successRows.length === 0} onClick={handleExportSuccess}>
              导出账号
            </Button>
          </Space>
        )}
      >
        <Row gutter={[16, 16]} style={{ marginBottom: 16 }}>
          <Col xs={12} md={4}><Statistic title="总数" value={batch?.total || 0} /></Col>
          <Col xs={12} md={4}><Statistic title="成功" value={batch?.success_count || 0} /></Col>
          <Col xs={12} md={4}><Statistic title="失败" value={batch?.failed_count || 0} /></Col>
          <Col xs={12} md={4}><Statistic title="运行中" value={batch?.running_count || 0} /></Col>
          <Col xs={12} md={4}><Statistic title="停止" value={batch?.stopped_count || 0} /></Col>
          <Col xs={12} md={4}><Statistic title="批次" value={batch?.batch_id || '-'} /></Col>
        </Row>
        <Table
          rowKey="line"
          columns={columns}
          dataSource={batch?.items || []}
          loading={refreshing && !isRunning}
          pagination={{ pageSize: 20, showSizeChanger: true }}
          scroll={{ x: 1320 }}
        />
      </Card>
    </Space>
  );
}