import { create } from "zustand";
import { persist } from "zustand/middleware";

export interface TimerPreset {
  id:      string;
  name:    string;
  minutes: number;
}

const DEFAULT_PRESETS: TimerPreset[] = [
  { id: "default-25", name: "25 Minuten", minutes: 25 },
  { id: "default-10", name: "10 Minuten", minutes: 10 },
  { id: "default-5",  name: "5 Minuten",  minutes: 5  },
];

interface TimerStore {
  presets:        TimerPreset[];
  activePresetId: string | null;
  secondsLeft:    number;   // current countdown display value
  secondsTotal:   number;   // full duration of current timer (for restart + progress)
  secondsAtStart: number;   // remaining when Start was pressed (for elapsed calc)
  startedAt:      number | null;
  isRunning:      boolean;
  isVisible:      boolean;
  isMinimized:    boolean;
  completionCount: number;   // increments each time timer naturally completes — component watches this

  show:           () => void;
  hide:           () => void;
  toggleMinimize: () => void;
  loadPreset:     (id: string) => void;
  addPreset:      (name: string, minutes: number) => void;
  removePreset:   (id: string) => void;
  start:          () => void;
  pause:          () => void;
  restart:        () => void;
  syncTick:       (now: number) => void;
  complete:       () => void;
}

export const useTimerStore = create<TimerStore>()(
  persist(
    (set, get) => ({
      presets:        DEFAULT_PRESETS,
      activePresetId: "default-25",
      secondsLeft:    25 * 60,
      secondsTotal:   25 * 60,
      secondsAtStart: 25 * 60,
      startedAt:      null,
      isRunning:      false,
      isVisible:      false,
      isMinimized:    false,
      completionCount: 0,

      show: () => set({ isVisible: true, isMinimized: false }),

      hide: () => {
        if (get().isRunning) get().pause();
        set({ isVisible: false });
      },

      toggleMinimize: () => set((s) => ({ isMinimized: !s.isMinimized })),

      loadPreset: (id) => {
        if (get().isRunning) return;
        const preset = get().presets.find((p) => p.id === id);
        if (!preset) return;
        const secs = preset.minutes * 60;
        set({ activePresetId: id, secondsLeft: secs, secondsTotal: secs, secondsAtStart: secs, startedAt: null });
      },

      addPreset: (name, minutes) => {
        const clamped = Math.max(1, Math.min(99, minutes));
        const id = `preset-${Date.now()}`;
        const preset: TimerPreset = { id, name: name.trim() || `${clamped} min`, minutes: clamped };
        set((s) => ({ presets: [...s.presets, preset] }));
      },

      removePreset: (id) => {
        if (id.startsWith("default-")) return;
        set((s) => ({
          presets:        s.presets.filter((p) => p.id !== id),
          activePresetId: s.activePresetId === id ? null : s.activePresetId,
        }));
      },

      start: () => {
        if (get().isRunning) return;
        set({ isRunning: true, startedAt: Date.now(), secondsAtStart: get().secondsLeft });
      },

      pause: () => {
        const { isRunning, startedAt, secondsAtStart } = get();
        if (!isRunning || !startedAt) return;
        const remaining = Math.max(0, secondsAtStart - Math.floor((Date.now() - startedAt) / 1000));
        set({ isRunning: false, startedAt: null, secondsLeft: remaining });
      },

      restart: () => {
        const { secondsTotal } = get();
        set({ isRunning: false, startedAt: null, secondsLeft: secondsTotal, secondsAtStart: secondsTotal });
      },

      syncTick: (now: number) => {
        const { isRunning, startedAt, secondsAtStart } = get();
        if (!isRunning || !startedAt) return;
        const remaining = secondsAtStart - Math.floor((now - startedAt) / 1000);
        if (remaining <= 0) get().complete();
        else set({ secondsLeft: remaining });
      },

      complete: () => {
        const { secondsTotal } = get();
        set((s) => ({
          isRunning: false, startedAt: null,
          secondsLeft: secondsTotal, secondsAtStart: secondsTotal,
          completionCount: s.completionCount + 1,
        }));
      },
    }),
    {
      name: "mindavio-timer-v2",
      partialize: (s) => ({
        presets:        s.presets,
        activePresetId: s.activePresetId,
        secondsLeft:    s.secondsLeft,
        secondsTotal:   s.secondsTotal,
        secondsAtStart: s.secondsAtStart,
        startedAt:      s.startedAt,
        isRunning:      s.isRunning,
        isVisible:      s.isVisible,
        isMinimized:    s.isMinimized,
        // completionCount intentionally omitted — it's a transient signal
      }),
    },
  ),
);