// ============================================================
// useScenarios — 用户自建情景管理 Hook
// 职责：封装自建情景的加载、创建、更新、删除逻辑，合并系统预置情景
// ============================================================

import { useCallback, useEffect, useState } from "react";
import { scenarios as systemScenarios } from "../lib/scenarios";
import * as api from "../lib/api/scenarios";

export interface ExtendedScenario {
  id: string;
  icon: string;
  name: string;        // 直接显示的名称（系统情景用 nameKey，自建情景用 name）
  nameKey?: string;    // i18n key（仅系统预置情景有）
  descKey?: string;    // i18n key（仅系统预置情景有）
  description?: string; // 直接显示的描述（自建情景）
  isCustom: boolean;   // true = 自建情景，false = 系统预置
  prompt?: string;     // 仅自建情景有
  greeting?: string;   // 仅自建情景有
  language?: string;   // 仅自建情景有
}

export function useScenarios(token: string | null) {
  const [customScenarios, setCustomScenarios] = useState<api.UserScenario[]>([]);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  // 合并系统预置 + 自建情景
  const allScenarios: ExtendedScenario[] = [
    // 系统预置情景
    ...systemScenarios.map((s) => ({
      id: s.id,
      icon: s.icon,
      name: s.nameKey,
      nameKey: s.nameKey,
      descKey: s.descKey,
      isCustom: false,
    })),
    // 用户自建情景
    ...customScenarios.map((s: api.UserScenario) => ({
      id: s.id,
      icon: s.icon,
      name: s.name,
      description: s.description,
      isCustom: true,
      prompt: s.prompt,
      greeting: s.greeting,
      language: s.language,
    })),
  ];

  // 加载用户自建情景
  const loadCustomScenarios = useCallback(async () => {
    if (!token) {
      setCustomScenarios([]);
      return;
    }

    setIsLoading(true);
    setError(null);
    try {
      const result = await api.listUserScenarios(token);
      setCustomScenarios(result.scenarios || []);
    } catch (err) {
      console.error("Failed to load custom scenarios:", err);
      setError(err instanceof Error ? err.message : "Unknown error");
    } finally {
      setIsLoading(false);
    }
  }, [token]);

  // 创建新情景
  const createScenario = useCallback(
    async (data: api.CreateScenarioRequest) => {
      if (!token) throw new Error("Not authenticated");

      setError(null);
      try {
        const newScenario = await api.createUserScenario(token, data);
        setCustomScenarios((prev) => [...prev, newScenario]);
        return newScenario;
      } catch (err) {
        const message = err instanceof Error ? err.message : "Unknown error";
        setError(message);
        throw err;
      }
    },
    [token]
  );

  // 更新情景
  const updateScenario = useCallback(
    async (id: string, data: api.UpdateScenarioRequest) => {
      if (!token) throw new Error("Not authenticated");

      setError(null);
      try {
        const updated = await api.updateUserScenario(token, id, data);
        setCustomScenarios((prev) =>
          prev.map((s) => (s.id === id ? updated : s))
        );
        return updated;
      } catch (err) {
        const message = err instanceof Error ? err.message : "Unknown error";
        setError(message);
        throw err;
      }
    },
    [token]
  );

  // 删除情景
  const deleteScenario = useCallback(
    async (id: string) => {
      if (!token) throw new Error("Not authenticated");

      setError(null);
      try {
        await api.deleteUserScenario(token, id);
        setCustomScenarios((prev) => prev.filter((s) => s.id !== id));
      } catch (err) {
        const message = err instanceof Error ? err.message : "Unknown error";
        setError(message);
        throw err;
      }
    },
    [token]
  );

  // 登录后自动加载
  useEffect(() => {
    if (token) {
      loadCustomScenarios();
    }
  }, [token, loadCustomScenarios]);

  return {
    allScenarios,
    customScenarios,
    isLoading,
    error,
    loadCustomScenarios,
    createScenario,
    updateScenario,
    deleteScenario,
  };
}
