export interface SuggestedQuestion {
  id: string;
  text: string;
  category: string;
  priority: number;
  context?: string[];
  analytics?: {
    clickCount: number;
    lastUsed: Date;
  };
}

export interface QuestionCategory {
  id: string;
  name: string;
  description: string;
  questions: SuggestedQuestion[];
}

export const DEFAULT_QUESTIONS: SuggestedQuestion[] = [
  {
    id: "general-1",
    text: "이 서비스는 어떤 기능을 제공하나요?",
    category: "general",
    priority: 1,
    context: ["welcome", "introduction"],
  },
  {
    id: "general-2",
    text: "어떻게 시작할 수 있나요?",
    category: "general",
    priority: 2,
    context: ["getting-started", "onboarding"],
  },
  {
    id: "general-3",
    text: "가격 정보가 궁금합니다",
    category: "pricing",
    priority: 3,
    context: ["pricing", "costs"],
  },
  {
    id: "support-1",
    text: "기술 지원은 어떻게 받을 수 있나요?",
    category: "support",
    priority: 4,
    context: ["support", "help"],
  },
  {
    id: "support-2",
    text: "계정 설정을 변경하고 싶어요",
    category: "account",
    priority: 5,
    context: ["account", "settings"],
  },
  {
    id: "features-1",
    text: "주요 기능들을 알려주세요",
    category: "features",
    priority: 6,
    context: ["features", "capabilities"],
  },
];

export const QUESTION_CATEGORIES: QuestionCategory[] = [
  {
    id: "general",
    name: "일반",
    description: "일반적인 정보와 소개",
    questions: DEFAULT_QUESTIONS.filter((q) => q.category === "general"),
  },
  {
    id: "pricing",
    name: "가격",
    description: "가격 및 요금제 정보",
    questions: DEFAULT_QUESTIONS.filter((q) => q.category === "pricing"),
  },
  {
    id: "support",
    name: "지원",
    description: "고객 지원 및 도움말",
    questions: DEFAULT_QUESTIONS.filter((q) => q.category === "support"),
  },
  {
    id: "account",
    name: "계정",
    description: "계정 관리 및 설정",
    questions: DEFAULT_QUESTIONS.filter((q) => q.category === "account"),
  },
  {
    id: "features",
    name: "기능",
    description: "제품 기능 및 사용법",
    questions: DEFAULT_QUESTIONS.filter((q) => q.category === "features"),
  },
];

// Context-based question suggestions
export const CONTEXTUAL_QUESTIONS: Record<string, SuggestedQuestion[]> = {
  welcome: [
    {
      id: "welcome-1",
      text: "무엇을 도와드릴까요?",
      category: "general",
      priority: 1,
    },
    {
      id: "welcome-2",
      text: "서비스 소개를 들려주세요",
      category: "general",
      priority: 2,
    },
    {
      id: "welcome-3",
      text: "어떻게 시작하면 되나요?",
      category: "general",
      priority: 3,
    },
  ],
  pricing: [
    {
      id: "pricing-1",
      text: "무료 플랜이 있나요?",
      category: "pricing",
      priority: 1,
    },
    {
      id: "pricing-2",
      text: "요금제별 차이점이 뭔가요?",
      category: "pricing",
      priority: 2,
    },
    {
      id: "pricing-3",
      text: "할인 혜택이 있나요?",
      category: "pricing",
      priority: 3,
    },
  ],
  error: [
    {
      id: "error-1",
      text: "다른 방법으로 질문해주세요",
      category: "support",
      priority: 1,
    },
    {
      id: "error-2",
      text: "고객 지원팀과 연결해주세요",
      category: "support",
      priority: 2,
    },
    {
      id: "error-3",
      text: "자주 묻는 질문을 보여주세요",
      category: "support",
      priority: 3,
    },
  ],
};

// Analytics tracking
export class QuestionAnalytics {
  private static readonly STORAGE_KEY = "chatbot-question-analytics";

  static trackQuestionClick(questionId: string): void {
    try {
      const analytics = this.getAnalytics();
      const existing = analytics[questionId];

      analytics[questionId] = {
        clickCount: (existing?.clickCount || 0) + 1,
        lastUsed: new Date(),
        questionId,
      };

      localStorage.setItem(this.STORAGE_KEY, JSON.stringify(analytics));
    } catch (error) {
      console.warn("Failed to track question analytics:", error);
    }
  }

  static getAnalytics(): Record<
    string,
    {
      clickCount: number;
      lastUsed: Date;
      questionId: string;
    }
  > {
    try {
      const stored = localStorage.getItem(this.STORAGE_KEY);
      if (!stored) return {};

      const parsed = JSON.parse(stored);

      // Convert date strings back to Date objects
      Object.values(parsed).forEach((item: any) => {
        if (item.lastUsed) {
          item.lastUsed = new Date(item.lastUsed);
        }
      });

      return parsed;
    } catch (error) {
      console.warn("Failed to get question analytics:", error);
      return {};
    }
  }

  static getMostPopularQuestions(limit: number = 5): SuggestedQuestion[] {
    const analytics = this.getAnalytics();
    const allQuestions = [...DEFAULT_QUESTIONS];

    // Add analytics data to questions
    const questionsWithAnalytics = allQuestions.map((question) => ({
      ...question,
      analytics: analytics[question.id] || {
        clickCount: 0,
        lastUsed: new Date(0),
      },
    }));

    // Sort by click count and recency
    questionsWithAnalytics.sort((a, b) => {
      const aAnalytics = a.analytics!;
      const bAnalytics = b.analytics!;

      // Primary sort by click count
      if (aAnalytics.clickCount !== bAnalytics.clickCount) {
        return bAnalytics.clickCount - aAnalytics.clickCount;
      }

      // Secondary sort by recency
      return bAnalytics.lastUsed.getTime() - aAnalytics.lastUsed.getTime();
    });

    return questionsWithAnalytics.slice(0, limit);
  }

  static clearAnalytics(): void {
    try {
      localStorage.removeItem(this.STORAGE_KEY);
    } catch (error) {
      console.warn("Failed to clear question analytics:", error);
    }
  }
}