// src/hooks/useCalculator.ts
import { useState, useEffect } from "react";
import {
  calculateMinimumProfit,
  calculateRepetitions,
  calculateStake,
  RepetitionResult,
} from "../utils/calculatorFunctions";

interface CalculatorState {
  percentage: number;
  max: number;
  odd1: number;
  odd2: number;
  stake: number;
  refund: number;
  repetitions: number;
  results: RepetitionResult[];
  minimumProfit: number;
}

export const useCalculator = () => {
  const [state, setState] = useState<CalculatorState>({
    percentage: 10,
    max: 10,
    odd1: 2.0,
    odd2: 1.95,
    stake: 750,
    refund: 10,
    repetitions: 2,
    results: [],
    minimumProfit: 0,
  });

  // Update stake based on percentage and max
  useEffect(() => {
    const newStake = calculateStake(state.percentage, state.max);
    setState((prev) => ({
      ...prev,
      stake: newStake,
      refund: state.max,
    }));
  }, [state.percentage, state.max]);

  // Calculate results whenever relevant values change
  useEffect(() => {
    const results = calculateRepetitions(
      state.stake,
      state.refund,
      state.odd1,
      state.odd2,
      state.repetitions,
    );

    const minimumProfit =
      results.length > 0 ? calculateMinimumProfit(results) : 0;

    setState((prev) => ({
      ...prev,
      results,
      minimumProfit,
    }));
  }, [state.stake, state.refund, state.odd1, state.odd2, state.repetitions]);

  // Handle input changes
  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const { id, value } = e.target;
    const numValue = parseFloat(value);

    if (id === "inputRepetitions") {
      setState((prev) => ({ ...prev, repetitions: numValue }));
      return;
    }

    setState((prev) => {
      const newState = { ...prev };
      if (id === "inputPercentage") {
        newState.percentage = numValue;
      } else if (id === "inputMax") {
        newState.max = numValue;
      } else if (id === "inputOdd1") {
        newState.odd1 = numValue;
      } else if (id === "inputOdd2") {
        newState.odd2 = numValue;
      } else if (id === "inputStake") {
        newState.stake = numValue;
      } else if (id === "inputRefund") {
        newState.refund = numValue;
      }

      if (id === "inputPercentage" || id === "inputMax") {
        newState.stake = calculateStake(
          id === "inputPercentage" ? numValue : newState.percentage,
          id === "inputMax" ? numValue : newState.max,
        );
        newState.refund = id === "inputMax" ? numValue : newState.max;
      }

      let bestRep = 1;
      let bestMin = -Infinity;
      let bestResults: RepetitionResult[] = [];
      for (let rip = 1; rip <= 5; rip++) {
        const results = calculateRepetitions(
          newState.stake,
          newState.refund,
          newState.odd1,
          newState.odd2,
          rip,
        );
        const min =
          results.length > 0 ? calculateMinimumProfit(results) : -Infinity;
        // Prefer larger rip if min is equal
        if (min > bestMin || (min === bestMin && rip > bestRep)) {
          bestMin = min;
          bestRep = rip;
          bestResults = results;
        }
      }

      newState.repetitions = bestRep;
      newState.results = bestResults;
      newState.minimumProfit = bestMin;
      return newState;
    });
  };

  // Swap odds
  const swapOdds = () => {
    setState((prev) => ({
      ...prev,
      odd1: prev.odd2,
      odd2: prev.odd1,
    }));
  };

  return {
    state,
    handleInputChange,
    swapOdds,
  };
};