import React, { useState, useEffect } from 'react';
import { PencilIcon, CheckIcon, XMarkIcon } from '@heroicons/react/24/outline';
import { SegmentMatchingRule, SegmentMatchingRuleHelper } from '../../types/template';
import { AiClassification } from '../../types/aiClassification';
import { useTemplateStore } from '../../stores/templateStore';
import { CustomSelect } from '../CustomSelect';
import { AiClassificationService } from '../../services/aiClassificationService';

interface SegmentMatchingRuleEditorProps {
  segmentId: string;
  currentRule: SegmentMatchingRule;
  onRuleUpdated?: (newRule: SegmentMatchingRule) => void;
}

/**
 * 片段匹配规则编辑器组件
 * 遵循前端开发规范的组件设计，支持固定素材和AI分类规则的设置
 */
export const SegmentMatchingRuleEditor: React.FC<SegmentMatchingRuleEditorProps> = ({
  segmentId,
  currentRule,
  onRuleUpdated,
}) => {
  const [isEditing, setIsEditing] = useState(false);
  const [editingRule, setEditingRule] = useState<SegmentMatchingRule>(currentRule);
  const [aiClassifications, setAiClassifications] = useState<AiClassification[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const { updateSegmentMatchingRule } = useTemplateStore();

  // 加载AI分类列表
  useEffect(() => {
    const loadClassifications = async () => {
      try {
        const classifications = await AiClassificationService.getActiveClassifications();
        setAiClassifications(classifications);
      } catch (error) {
        console.error('加载AI分类失败:', error);
      }
    };

    if (isEditing) {
      loadClassifications();
    }
  }, [isEditing]);

  // 重置编辑状态
  useEffect(() => {
    setEditingRule(currentRule);
    setError(null);
  }, [currentRule, isEditing]);

  const handleStartEdit = () => {
    setIsEditing(true);
    setEditingRule(currentRule);
    setError(null);
  };

  const handleCancelEdit = () => {
    setIsEditing(false);
    setEditingRule(currentRule);
    setError(null);
  };

  const handleSaveRule = async () => {
    try {
      setLoading(true);
      setError(null);

      await updateSegmentMatchingRule(segmentId, editingRule);
      
      setIsEditing(false);
      onRuleUpdated?.(editingRule);
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : '保存匹配规则失败';
      setError(errorMessage);
    } finally {
      setLoading(false);
    }
  };

  const handleRuleTypeChange = (ruleType: string) => {
    if (ruleType === 'fixed') {
      setEditingRule(SegmentMatchingRuleHelper.createFixedMaterial());
    } else if (ruleType === 'ai_classification') {
      // 如果有可用的AI分类，选择第一个作为默认值
      if (aiClassifications.length > 0) {
        const firstClassification = aiClassifications[0];
        setEditingRule(SegmentMatchingRuleHelper.createAiClassification(
          firstClassification.id,
          firstClassification.name
        ));
      }
    } else if (ruleType === 'random') {
      setEditingRule(SegmentMatchingRuleHelper.createRandomMatch());
    }
  };

  const handleAiClassificationChange = (classificationId: string) => {
    const classification = aiClassifications.find(c => c.id === classificationId);
    if (classification) {
      setEditingRule(SegmentMatchingRuleHelper.createAiClassification(
        classification.id,
        classification.name
      ));
    }
  };

  const getCurrentRuleType = (rule: SegmentMatchingRule): string => {
    if (SegmentMatchingRuleHelper.isFixedMaterial(rule)) {
      return 'fixed';
    } else if (SegmentMatchingRuleHelper.isAiClassification(rule)) {
      return 'ai_classification';
    } else if (SegmentMatchingRuleHelper.isRandomMatch(rule)) {
      return 'random';
    }
    return 'fixed'; // 默认值
  };

  const ruleTypeOptions = [
    { value: 'fixed', label: '固定素材' },
    { value: 'ai_classification', label: 'AI分类素材' },
    { value: 'random', label: '随机匹配' },
  ];

  const classificationOptions = aiClassifications.map(classification => ({
    value: classification.id,
    label: classification.name,
  }));

  if (!isEditing) {
    return (
      <div className="flex items-center justify-between">
        <div className="flex items-center space-x-2">
          <span className="text-xs font-medium text-gray-700">匹配规则:</span>
          <span className={`px-2 py-1 rounded text-xs ${
            SegmentMatchingRuleHelper.isFixedMaterial(currentRule)
              ? 'bg-gray-100 text-gray-800'
              : SegmentMatchingRuleHelper.isAiClassification(currentRule)
              ? 'bg-blue-100 text-blue-800'
              : SegmentMatchingRuleHelper.isRandomMatch(currentRule)
              ? 'bg-green-100 text-green-800'
              : 'bg-gray-100 text-gray-800'
          }`}>
            {SegmentMatchingRuleHelper.getDisplayName(currentRule)}
          </span>
        </div>
        <button
          onClick={handleStartEdit}
          className="inline-flex items-center px-2 py-1 bg-blue-50 text-blue-600 text-xs font-medium rounded-md hover:bg-blue-100 hover:text-blue-700 transition-all duration-200 border border-blue-200"
          title="编辑匹配规则"
        >
          <PencilIcon className="w-3 h-3 mr-1" />
          编辑
        </button>
      </div>
    );
  }

  return (
    <div className="space-y-3 bg-blue-50 border border-blue-200 rounded-lg p-3">
      <div className="flex items-center justify-between">
        <span className="text-xs font-medium text-blue-800">编辑匹配规则:</span>
        <div className="flex items-center space-x-2">
          <button
            onClick={handleSaveRule}
            disabled={loading}
            className="inline-flex items-center px-3 py-1.5 bg-green-600 text-white text-xs font-medium rounded-md hover:bg-green-700 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200 shadow-sm hover:shadow-md"
            title="保存匹配规则"
          >
            <CheckIcon className="w-3 h-3 mr-1" />
            {loading ? '保存中...' : '保存'}
          </button>
          <button
            onClick={handleCancelEdit}
            disabled={loading}
            className="inline-flex items-center px-3 py-1.5 bg-gray-100 text-gray-700 text-xs font-medium rounded-md hover:bg-gray-200 disabled:opacity-50 disabled:cursor-not-allowed transition-all duration-200"
            title="取消编辑"
          >
            <XMarkIcon className="w-3 h-3 mr-1" />
            取消
          </button>
        </div>
      </div>

      <div className="space-y-2">
        <div>
          <label className="block text-xs font-medium text-blue-800 mb-1">
            规则类型
          </label>
          <CustomSelect
            value={getCurrentRuleType(editingRule)}
            onChange={handleRuleTypeChange}
            options={ruleTypeOptions}
            placeholder="选择规则类型"
            className="text-xs bg-white border-blue-200"
          />
        </div>

        {SegmentMatchingRuleHelper.isAiClassification(editingRule) && (
          <div>
            <label className="block text-xs font-medium text-blue-800 mb-1">
              AI分类
            </label>
            <CustomSelect
              value={SegmentMatchingRuleHelper.getAiClassificationInfo(editingRule)?.category_id || ''}
              onChange={handleAiClassificationChange}
              options={classificationOptions}
              placeholder="选择AI分类"
              className="text-xs bg-white border-blue-200"
            />
          </div>
        )}
      </div>

      {error && (
        <div className="text-xs text-red-700 bg-red-100 border border-red-200 p-2 rounded-md">
          ⚠️ {error}
        </div>
      )}

      {loading && (
        <div className="text-xs text-blue-700 bg-white border border-blue-300 p-2 rounded-md flex items-center">
          <div className="animate-spin rounded-full h-3 w-3 border-b-2 border-blue-600 mr-2"></div>
          正在保存匹配规则...
        </div>
      )}
    </div>
  );
};
