import { create } from "zustand";

import {
  generateSession,
  gradeAnswer,
} from "@/lib/engine/parenthesis-sign";
import type {
  GradeResult,
  ParenthesisSignProblem,
  UserAnswer,
} from "@/lib/engine/types";

interface GameSession {
  problems: ParenthesisSignProblem[];
  currentIndex: number;
  results: (GradeResult | null)[];
}

interface GameState {
  session: GameSession | null;
  initSession: (count?: number) => void;
  submitAnswer: (answer: UserAnswer) => void;
  nextProblem: () => void;
  resetSession: () => void;
  currentProblem: () => ParenthesisSignProblem | null;
  currentResult: () => GradeResult | null;
  isComplete: () => boolean;
  score: () => { correct: number; total: number };
}

const DEFAULT_SESSION_COUNT = 10;

function createSession(count = DEFAULT_SESSION_COUNT): GameSession {
  const problems = generateSession(count);

  return {
    problems,
    currentIndex: 0,
    results: problems.map(() => null),
  };
}

export const useGameStore = create<GameState>((set, get) => ({
  session: null,
  initSession: (count = DEFAULT_SESSION_COUNT) => {
    set({ session: createSession(count) });
  },
  submitAnswer: (answer) => {
    const { session } = get();

    if (!session || session.currentIndex >= session.problems.length) return;
    if (session.results[session.currentIndex] !== null) return;

    const problem = session.problems[session.currentIndex];
    const result = gradeAnswer(problem, answer);
    const results = [...session.results];
    results[session.currentIndex] = result;

    set({
      session: {
        ...session,
        results,
      },
    });
  },
  nextProblem: () => {
    const { session } = get();

    if (!session || session.currentIndex >= session.problems.length) return;
    if (session.results[session.currentIndex] === null) return;

    set({
      session: {
        ...session,
        currentIndex: session.currentIndex + 1,
      },
    });
  },
  resetSession: () => {
    set({ session: createSession() });
  },
  currentProblem: () => {
    const { session } = get();

    if (!session) return null;
    return session.problems[session.currentIndex] ?? null;
  },
  currentResult: () => {
    const { session } = get();

    if (!session) return null;
    return session.results[session.currentIndex] ?? null;
  },
  isComplete: () => {
    const { session } = get();

    return Boolean(session && session.currentIndex >= session.problems.length);
  },
  score: () => {
    const { session } = get();

    if (!session) return { correct: 0, total: 0 };

    return {
      correct: session.results.filter((result) => result?.correct).length,
      total: session.problems.length,
    };
  },
}));