import { useCallback, useRef, useState } from 'react';
import { generateProblemFraming } from '../../../infrastructure/api/api';
import type { OutputMode, ProblemFramingPlan, Quality, ReferenceImage } from '../../../shared/types/api';
import { useI18n } from '../../../shared/i18n/index';
import { loadPrompts } from '../../prompts/hooks/usePrompts';

interface GenerationDraft {
  concept: string;
  quality: Quality;
  outputMode: OutputMode;
  referenceImages?: ReferenceImage[];
}

interface StartPlanOptions {
  request: GenerationDraft;
  feedback?: string;
}

interface RefinePlanOptions {
  feedback: string;
}

interface UseProblemFramingResult {
  status: 'idle' | 'loading' | 'ready' | 'error';
  plan: ProblemFramingPlan | null;
  error: string | null;
  draft: GenerationDraft | null;
  startPlan: (options: StartPlanOptions) => Promise<void>;
  refinePlan: (options: RefinePlanOptions) => Promise<void>;
  retryPlan: () => Promise<void>;
  updatePlan: (plan: ProblemFramingPlan) => void;
  reset: () => void;
}

export function useProblemFraming(): UseProblemFramingResult {
  const { locale, t } = useI18n();
  const [status, setStatus] = useState<'idle' | 'loading' | 'ready' | 'error'>('idle');
  const [plan, setPlan] = useState<ProblemFramingPlan | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [draft, setDraft] = useState<GenerationDraft | null>(null);
  const [feedbackHistory, setFeedbackHistory] = useState<string[]>([]);
  const abortControllerRef = useRef<AbortController | null>(null);
  const requestSequenceRef = useRef(0);

  const callPlanner = useCallback(async (
    request: GenerationDraft,
    feedback?: string,
    currentPlan?: ProblemFramingPlan | null,
    history?: string[]
  ) => {
    abortControllerRef.current?.abort();
    abortControllerRef.current = new AbortController();

    return generateProblemFraming(
      {
        concept: request.concept,
        feedback,
        feedbackHistory: history && history.length ? history : undefined,
        currentPlan: currentPlan || undefined,
        locale,
        referenceImages: request.referenceImages,
        promptOverrides: loadPrompts(locale),
      },
      abortControllerRef.current.signal
    );
  }, [locale]);

  const startPlan = useCallback(async ({ request, feedback }: StartPlanOptions) => {
    const requestId = ++requestSequenceRef.current;
    setStatus('loading');
    setError(null);
    setPlan(null);
    setDraft(request);
    const trimmedFeedback = feedback?.trim();
    const nextHistory = trimmedFeedback ? [trimmedFeedback] : [];
    setFeedbackHistory(nextHistory);

    try {
      const response = await callPlanner(request, trimmedFeedback, undefined, nextHistory);
      if (requestId !== requestSequenceRef.current) return;
      setPlan(response.plan);
      setStatus('ready');
    } catch (err) {
      if (requestId !== requestSequenceRef.current || (err instanceof Error && err.name === 'AbortError')) {
        return;
      }
      setStatus('error');
      setError(err instanceof Error ? err.message : t('generation.problemFramingFailed'));
    }
  }, [callPlanner, t]);

  const refinePlan = useCallback(async ({ feedback }: RefinePlanOptions) => {
    if (!draft) {
      return;
    }

    const requestId = ++requestSequenceRef.current;
    setStatus('loading');
    setError(null);
    const trimmedFeedback = feedback.trim();
    const nextHistory = trimmedFeedback ? [...feedbackHistory, trimmedFeedback] : feedbackHistory;

    try {
      const response = await callPlanner(draft, trimmedFeedback, plan, nextHistory);
      if (requestId !== requestSequenceRef.current) return;
      setPlan(response.plan);
      setFeedbackHistory(nextHistory);
      setStatus('ready');
    } catch (err) {
      if (requestId !== requestSequenceRef.current || (err instanceof Error && err.name === 'AbortError')) {
        return;
      }
      setStatus('error');
      setError(err instanceof Error ? err.message : t('generation.problemFramingFailed'));
    }
  }, [callPlanner, draft, feedbackHistory, plan, t]);

  const retryPlan = useCallback(async () => {
    if (!draft) return;

    const requestId = ++requestSequenceRef.current;
    setStatus('loading');
    setError(null);

    try {
      const response = await callPlanner(draft, undefined, undefined, feedbackHistory);
      if (requestId !== requestSequenceRef.current) return;
      setPlan(response.plan);
      setStatus('ready');
    } catch (err) {
      if (requestId !== requestSequenceRef.current || (err instanceof Error && err.name === 'AbortError')) {
        return;
      }
      setStatus('error');
      setError(err instanceof Error ? err.message : t('generation.problemFramingFailed'));
    }
  }, [callPlanner, draft, feedbackHistory, t]);

  const updatePlan = useCallback((nextPlan: ProblemFramingPlan) => {
    setPlan(nextPlan);
  }, []);

  const reset = useCallback(() => {
    requestSequenceRef.current += 1;
    abortControllerRef.current?.abort();
    setStatus('idle');
    setPlan(null);
    setError(null);
    setDraft(null);
    setFeedbackHistory([]);
  }, []);

  return {
    status,
    plan,
    error,
    draft,
    startPlan,
    refinePlan,
    retryPlan,
    updatePlan,
    reset,
  };
}