import { create } from 'zustand';
import { generateUUID } from '../utils/uuid';
import { isPiBoardKind } from '../types/board';
import { getProBoard } from '../lib/proBoardRegistry';

export interface WorkspaceFile {
  id: string;
  name: string;
  content: string;
  modified: boolean;
}

const MAIN_ID = 'main-sketch';

/** Trim, collapse slashes/backslashes, strip leading/trailing '/' and any
 *  '.'/'..' segments — folder paths are always workspace-relative. */
export function normalizeFolderPath(path: string): string {
  return path
    .trim()
    .replace(/\\/g, '/')
    .split('/')
    .map((seg) => seg.trim())
    .filter((seg) => seg && seg !== '.' && seg !== '..')
    .join('/');
}

const DEFAULT_INO_CONTENT = `// Arduino Blink Example
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}`;

const DEFAULT_MICROPYTHON_CONTENT = `# MicroPython Blink for Raspberry Pi Pico
from machine import Pin
import time

led = Pin(25, Pin.OUT)

while True:
    led.toggle()
    time.sleep(1)
`;

// The shipped ESP32-family MicroPython is v1.28.0 (IDF 5.x drivers — the
// same generation the compile pipeline and the JS engines are validated
// against), so Pin.toggle() and friends exist now; this seed just stays on
// the lowest-common API. History: #122 (v1.20 had no Pin.toggle).
const DEFAULT_ESP32_MICROPYTHON_CONTENT = `# MicroPython Blink for ESP32
from machine import Pin
import time

led = Pin(2, Pin.OUT)  # Built-in LED on GPIO 2
state = False

while True:
    state = not state
    led.value(state)
    time.sleep(1)
`;

// Pure ESP-IDF mode (issue #139): the user's own app_main(), compiled by the
// backend's ESP-IDF toolchain WITHOUT the arduino-esp32 component. GPIO 2 is
// the built-in LED on most ESP32 dev boards.
const DEFAULT_ESPIDF_CONTENT = `// ESP-IDF Blink Example
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_PIN GPIO_NUM_2

void app_main(void)
{
    gpio_reset_pin(LED_PIN);
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);

    while (1) {
        gpio_set_level(LED_PIN, 1);
        vTaskDelay(pdMS_TO_TICKS(1000));
        gpio_set_level(LED_PIN, 0);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
`;

const DEFAULT_PY_CONTENT = `import RPi.GPIO as GPIO
import time

LED_PIN = 17

GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)

try:
    while True:
        GPIO.output(LED_PIN, GPIO.HIGH)
        time.sleep(1)
        GPIO.output(LED_PIN, GPIO.LOW)
        time.sleep(1)
except KeyboardInterrupt:
    GPIO.cleanup()
`;

const DEFAULT_FILE: WorkspaceFile = {
  id: MAIN_ID,
  name: 'sketch.ino',
  content: DEFAULT_INO_CONTENT,
  modified: false,
};

/** Default file group for the initial Arduino Uno board */
const DEFAULT_GROUP_ID = 'group-arduino-uno';

/**
 * Editor file group id for a programmable custom-chip's program.
 *
 * A custom chip that loads a ROM / runs a user program (a CPU emulator such
 * as the Z80 or 8080) keeps that program (`larson.s`, `chaser.c`, …) in its
 * OWN file group, exactly like each board owns one. The file explorer renders
 * it as a separate collapsible section, so the chip's program never gets
 * mixed into the board's sketch. Behaviour/driver chips (a servo driver, a
 * sensor) and predefined chips carry no program file and get no group — they
 * are edited in the chip designer instead.
 */
export const chipFileGroupId = (chipId: string): string => `group-chip-${chipId}`;
/** Prefix shared by every chip program group — used to sweep stale ones. */
export const CHIP_GROUP_PREFIX = 'group-chip-';

/**
 * Editor view layout. Lets the user collapse either pane to give the chat
 * (right-docked) more breathing room, or to focus on one half of the
 * workflow.
 */
export type EditorViewMode = 'code' | 'circuit' | 'both';

interface EditorState {
  files: WorkspaceFile[];
  activeFileId: string;
  openFileIds: string[];
  /** When set, the editor shows a READ-ONLY `libraries.json` view of this
   *  board's library manifest (board.libraries) instead of the active file.
   *  Cleared whenever a real file is opened/activated. Managed by the explorer's
   *  libraries.json entry; the Library Manager modal is what edits the manifest. */
  manifestViewBoardId: string | null;
  setManifestView: (boardId: string | null) => void;
  theme: 'vs-dark' | 'light';
  fontSize: number;
  viewMode: EditorViewMode;
  setViewMode: (mode: EditorViewMode) => void;
  /** Desktop file-explorer pane. Lives in the store (not EditorPage state) so
   *  the header's View menu can show its checkmark and toggle it — the
   *  toolbar's own segmented toggle hides on narrow bars. */
  explorerOpen: boolean;
  setExplorerOpen: (open: boolean) => void;
  toggleExplorer: () => void;

  // ── File groups (one per board) ──────────────────────────────────────────
  /** Map of groupId → WorkspaceFile[]. Stored as plain object for Zustand. */
  fileGroups: Record<string, WorkspaceFile[]>;
  /** Active group (determines which board's files are shown in the editor). */
  activeGroupId: string;
  /** Active file within the active group */
  activeGroupFileId: Record<string, string>;
  /** Open file IDs within each group */
  openGroupFileIds: Record<string, string[]>;

  // ── Folders ──────────────────────────────────────────────────────────────
  /**
   * Folders exist implicitly through file names containing '/'
   * ("apps/badge/__init__.py" lives in apps/badge). This map only tracks
   * EMPTY folders per group (created but not yet holding a file) so they
   * survive in the explorer until a file lands in them. Paths are
   * '/'-separated with no leading/trailing slash.
   */
  folderGroups: Record<string, string[]>;
  /** Create a folder (in the active group). No-op if it already exists. */
  createFolder: (path: string) => void;
  /** Delete a folder (active group): removes every file under it and any
   *  tracked empty subfolders. */
  deleteFolder: (path: string) => void;

  // File operations (operate on active group)
  createFile: (name: string) => string;
  deleteFile: (id: string) => void;
  renameFile: (id: string, newName: string) => void;
  setFileContent: (id: string, content: string) => void;
  markFileSaved: (id: string) => void;
  openFile: (id: string) => void;
  closeFile: (id: string) => void;
  setActiveFile: (id: string) => void;
  /** Load a full set of files (e.g. when loading a saved project) */
  loadFiles: (files: { name: string; content: string }[]) => void;

  // File group management
  createFileGroup: (
    groupId: string,
    languageModeOrFiles?: string | { name: string; content: string }[],
  ) => void;
  deleteFileGroup: (groupId: string) => void;
  setActiveGroup: (groupId: string) => void;
  getGroupFiles: (groupId: string) => WorkspaceFile[];
  updateGroupFile: (groupId: string, fileId: string, content: string) => void;
  /** Replace ALL file groups atomically (used when loading a saved project).
   *  `folders` restores the tracked EMPTY folders per group (optional —
   *  folders holding files rebuild themselves from the file name prefixes). */
  replaceFileGroups: (
    groups: Record<string, { name: string; content: string }[]>,
    folders?: Record<string, string[]>,
  ) => void;

  // Settings
  setTheme: (theme: 'vs-dark' | 'light') => void;
  setFontSize: (size: number) => void;

  // Dirty flag — tracks whether code changed since last compilation
  codeChangedSinceLastCompile: boolean;
  markCompiled: () => void;

  // Legacy compat — sets content of the active file
  setCode: (code: string) => void;
}

export const useEditorStore = create<EditorState>((set, get) => ({
  files: [DEFAULT_FILE],
  activeFileId: MAIN_ID,
  openFileIds: [MAIN_ID],
  manifestViewBoardId: null,
  setManifestView: (boardId: string | null) => set({ manifestViewBoardId: boardId }),
  theme: 'vs-dark',
  fontSize: 14,
  viewMode: 'both',
  setViewMode: (mode) => set({ viewMode: mode }),
  explorerOpen: true,
  setExplorerOpen: (open) => set({ explorerOpen: open }),
  toggleExplorer: () => set((s) => ({ explorerOpen: !s.explorerOpen })),

  // File groups — initial state has one group for the default Arduino Uno board
  fileGroups: {
    [DEFAULT_GROUP_ID]: [DEFAULT_FILE],
  },
  folderGroups: {},
  activeGroupId: DEFAULT_GROUP_ID,
  activeGroupFileId: { [DEFAULT_GROUP_ID]: MAIN_ID },
  openGroupFileIds: { [DEFAULT_GROUP_ID]: [MAIN_ID] },

  codeChangedSinceLastCompile: true,
  markCompiled: () => set({ codeChangedSinceLastCompile: false }),

  // ── Folder operations (operate on active group) ─────────────────────────

  createFolder: (path: string) => {
    const clean = normalizeFolderPath(path);
    if (!clean) return;
    set((s) => {
      const groupId = s.activeGroupId;
      const folders = s.folderGroups[groupId] ?? [];
      const files = s.fileGroups[groupId] ?? [];
      const exists =
        folders.includes(clean) || files.some((f) => f.name.startsWith(clean + '/'));
      if (exists) return {};
      return { folderGroups: { ...s.folderGroups, [groupId]: [...folders, clean] } };
    });
  },

  deleteFolder: (path: string) => {
    const clean = normalizeFolderPath(path);
    if (!clean) return;
    set((s) => {
      const groupId = s.activeGroupId;
      const prefix = clean + '/';
      const doomed = new Set(
        (s.fileGroups[groupId] ?? []).filter((f) => f.name.startsWith(prefix)).map((f) => f.id),
      );
      const files = s.files.filter((f) => !doomed.has(f.id));
      const openFileIds = s.openFileIds.filter((fid) => !doomed.has(fid));
      let activeFileId = s.activeFileId;
      if (doomed.has(activeFileId)) activeFileId = openFileIds[0] ?? files[0]?.id ?? '';
      const groupFiles = (s.fileGroups[groupId] ?? []).filter((f) => !doomed.has(f.id));
      const groupOpenIds = (s.openGroupFileIds[groupId] ?? []).filter((fid) => !doomed.has(fid));
      const folders = (s.folderGroups[groupId] ?? []).filter(
        (p) => p !== clean && !p.startsWith(prefix),
      );
      return {
        files,
        openFileIds,
        activeFileId,
        fileGroups: { ...s.fileGroups, [groupId]: groupFiles },
        openGroupFileIds: { ...s.openGroupFileIds, [groupId]: groupOpenIds },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: activeFileId },
        folderGroups: { ...s.folderGroups, [groupId]: folders },
      };
    });
  },

  // ── File operations (legacy API — operate on active group) ──────────────

  createFile: (name: string) => {
    const id = generateUUID();
    const newFile: WorkspaceFile = { id, name, content: '', modified: false };
    set((s) => {
      const groupId = s.activeGroupId;
      const groupFiles = [...(s.fileGroups[groupId] ?? []), newFile];
      // A file landing inside a tracked empty folder materialises it — the
      // folder now exists through the file's path prefix.
      const folders = (s.folderGroups[groupId] ?? []).filter((p) => !name.startsWith(p + '/'));
      return {
        // Legacy flat list (mirrors active group)
        files: [...s.files, newFile],
        openFileIds: [...s.openFileIds, id],
        activeFileId: id,
        // Group-aware state
        fileGroups: { ...s.fileGroups, [groupId]: groupFiles },
        openGroupFileIds: {
          ...s.openGroupFileIds,
          [groupId]: [...(s.openGroupFileIds[groupId] ?? []), id],
        },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: id },
        folderGroups: { ...s.folderGroups, [groupId]: folders },
      };
    });
    return id;
  },

  deleteFile: (id: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const files = s.files.filter((f) => f.id !== id);
      const openFileIds = s.openFileIds.filter((fid) => fid !== id);
      let activeFileId = s.activeFileId;
      if (activeFileId === id) {
        const idx = s.openFileIds.indexOf(id);
        activeFileId =
          openFileIds[idx] ?? openFileIds[idx - 1] ?? openFileIds[0] ?? files[0]?.id ?? '';
      }
      const groupFiles = (s.fileGroups[groupId] ?? []).filter((f) => f.id !== id);
      const groupOpenIds = (s.openGroupFileIds[groupId] ?? []).filter((fid) => fid !== id);
      return {
        files,
        openFileIds,
        activeFileId,
        fileGroups: { ...s.fileGroups, [groupId]: groupFiles },
        openGroupFileIds: { ...s.openGroupFileIds, [groupId]: groupOpenIds },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: activeFileId },
      };
    });
  },

  renameFile: (id: string, newName: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const mapper = (f: WorkspaceFile) =>
        f.id === id ? { ...f, name: newName, modified: true } : f;
      return {
        files: s.files.map(mapper),
        fileGroups: { ...s.fileGroups, [groupId]: (s.fileGroups[groupId] ?? []).map(mapper) },
      };
    });
  },

  setFileContent: (id: string, content: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const mapper = (f: WorkspaceFile) => (f.id === id ? { ...f, content, modified: true } : f);
      return {
        files: s.files.map(mapper),
        fileGroups: { ...s.fileGroups, [groupId]: (s.fileGroups[groupId] ?? []).map(mapper) },
        codeChangedSinceLastCompile: true,
      };
    });
  },

  markFileSaved: (id: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const mapper = (f: WorkspaceFile) => (f.id === id ? { ...f, modified: false } : f);
      return {
        files: s.files.map(mapper),
        fileGroups: { ...s.fileGroups, [groupId]: (s.fileGroups[groupId] ?? []).map(mapper) },
      };
    });
  },

  openFile: (id: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const groupOpenIds = s.openGroupFileIds[groupId] ?? [];
      return {
        openFileIds: s.openFileIds.includes(id) ? s.openFileIds : [...s.openFileIds, id],
        activeFileId: id,
        manifestViewBoardId: null, // opening a real file exits the libraries.json view
        openGroupFileIds: {
          ...s.openGroupFileIds,
          [groupId]: groupOpenIds.includes(id) ? groupOpenIds : [...groupOpenIds, id],
        },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: id },
      };
    });
  },

  closeFile: (id: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      const openFileIds = s.openFileIds.filter((fid) => fid !== id);
      let activeFileId = s.activeFileId;
      if (activeFileId === id) {
        const idx = s.openFileIds.indexOf(id);
        activeFileId = openFileIds[idx] ?? openFileIds[idx - 1] ?? openFileIds[0] ?? '';
      }
      const groupOpenIds = (s.openGroupFileIds[groupId] ?? []).filter((fid) => fid !== id);
      return {
        openFileIds,
        activeFileId,
        openGroupFileIds: { ...s.openGroupFileIds, [groupId]: groupOpenIds },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: activeFileId },
      };
    });
  },

  setActiveFile: (id: string) => {
    set((s) => {
      const groupId = s.activeGroupId;
      return {
        activeFileId: id,
        manifestViewBoardId: null, // activating a real file exits the libraries.json view
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: id },
      };
    });
  },

  loadFiles: (incoming: { name: string; content: string }[]) => {
    const files: WorkspaceFile[] = incoming.map((f, i) => ({
      id: i === 0 ? MAIN_ID : generateUUID(),
      name: f.name,
      content: f.content,
      modified: false,
    }));
    const firstId = files[0]?.id ?? MAIN_ID;
    set((s) => {
      const groupId = s.activeGroupId;
      return {
        files,
        activeFileId: firstId,
        openFileIds: [firstId],
        fileGroups: { ...s.fileGroups, [groupId]: files },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: firstId },
        openGroupFileIds: { ...s.openGroupFileIds, [groupId]: [firstId] },
      };
    });
  },

  // ── File group management ─────────────────────────────────────────────────

  createFileGroup: (
    groupId: string,
    languageModeOrFiles?: string | { name: string; content: string }[],
  ) => {
    set((s) => {
      if (s.fileGroups[groupId]) return s; // already exists

      // Resolve overloaded parameter
      const initialFiles = Array.isArray(languageModeOrFiles) ? languageModeOrFiles : undefined;
      const languageMode =
        typeof languageModeOrFiles === 'string' ? languageModeOrFiles : undefined;

      let files: WorkspaceFile[];
      if (initialFiles && initialFiles.length > 0) {
        files = initialFiles.map((f, i) => ({
          id: i === 0 ? `${groupId}-main` : generateUUID(),
          name: f.name,
          content: f.content,
          modified: false,
        }));
      } else {
        // Determine default file by group name convention or language mode.
        // All QEMU-Linux boards (Pi Zero/1/2/3/4/5 plus overlay piFamily
        // kinds like the UNIHIKER) default to script.py. Group ids follow
        // `group-<boardId>`; the first board of a kind uses the kind as its
        // id, later instances append '-N'. Test the FULL id first — kinds
        // themselves end in digits ('raspberry-pi-3'), so stripping the
        // numeric suffix unconditionally would mangle them ('raspberry-pi'
        // matched nothing and Pis regressed to sketch.ino).
        const boardIdPart = groupId.replace(/^group-/, '');
        const isPi =
          isPiBoardKind(boardIdPart) || isPiBoardKind(boardIdPart.replace(/-\d+$/, ''));
        const isMicroPython = languageMode === 'micropython';
        const mainId = `${groupId}-main`;
        let fileName: string;
        let content: string;
        // ESP32 by id ('group-esp32-c3') or by the overlay board's declared
        // family — an overlay kind can be an ESP32 with no 'esp32' in its name
        // (m5stack-core, cardputer-adv), and those used to be seeded the Pico's
        // `Pin(25)` blink, a dead pin on both.
        const isEsp32 =
          groupId.includes('esp32') ||
          getProBoard(boardIdPart)?.esp32Family !== undefined ||
          getProBoard(boardIdPart.replace(/-\d+$/, ''))?.esp32Family !== undefined;
        if (languageMode === 'espidf') {
          fileName = 'main.c';
          content = DEFAULT_ESPIDF_CONTENT;
        } else if (isMicroPython && isEsp32) {
          fileName = 'main.py';
          content = DEFAULT_ESP32_MICROPYTHON_CONTENT;
        } else if (isMicroPython) {
          fileName = 'main.py';
          content = DEFAULT_MICROPYTHON_CONTENT;
        } else if (isPi) {
          fileName = 'script.py';
          content = DEFAULT_PY_CONTENT;
        } else {
          fileName = 'sketch.ino';
          content = DEFAULT_INO_CONTENT;
        }
        files = [{ id: mainId, name: fileName, content, modified: false }];
      }

      const firstId = files[0]?.id ?? `${groupId}-main`;
      return {
        fileGroups: { ...s.fileGroups, [groupId]: files },
        activeGroupFileId: { ...s.activeGroupFileId, [groupId]: firstId },
        openGroupFileIds: { ...s.openGroupFileIds, [groupId]: [firstId] },
      };
    });
  },

  deleteFileGroup: (groupId: string) => {
    set((s) => {
      const { [groupId]: _removed, ...rest } = s.fileGroups;
      const { [groupId]: _a, ...restActive } = s.activeGroupFileId;
      const { [groupId]: _o, ...restOpen } = s.openGroupFileIds;
      const { [groupId]: _f, ...restFolders } = s.folderGroups;
      // Never leave activeGroupId dangling at the deleted group: Monaco (and
      // every agent write_file) keeps targeting it, while compile reads the
      // board's group — two same-named sketch.ino files silently diverge and
      // the build ships the WRONG one (the "leftover template Blink compiled
      // instead of my code" class). Re-point at any surviving group.
      const nextActive =
        s.activeGroupId === groupId ? Object.keys(rest)[0] ?? '' : s.activeGroupId;
      return {
        fileGroups: rest,
        activeGroupFileId: restActive,
        openGroupFileIds: restOpen,
        folderGroups: restFolders,
        activeGroupId: nextActive,
      };
    });
  },

  setActiveGroup: (groupId: string) => {
    set((s) => {
      const groupFiles = s.fileGroups[groupId] ?? [];
      const activeFileId = s.activeGroupFileId[groupId] ?? groupFiles[0]?.id ?? '';
      const openFileIds = s.openGroupFileIds[groupId] ?? (groupFiles[0] ? [groupFiles[0].id] : []);
      return {
        activeGroupId: groupId,
        files: groupFiles,
        activeFileId,
        openFileIds,
      };
    });
  },

  getGroupFiles: (groupId: string) => {
    return get().fileGroups[groupId] ?? [];
  },

  updateGroupFile: (groupId: string, fileId: string, content: string) => {
    set((s) => {
      const groupFiles = (s.fileGroups[groupId] ?? []).map((f) =>
        f.id === fileId ? { ...f, content, modified: true } : f,
      );
      return { fileGroups: { ...s.fileGroups, [groupId]: groupFiles } };
    });
  },

  replaceFileGroups: (groups, folders) => {
    const fileGroups: Record<string, WorkspaceFile[]> = {};
    const activeGroupFileId: Record<string, string> = {};
    const openGroupFileIds: Record<string, string[]> = {};
    for (const [gid, files] of Object.entries(groups)) {
      const wsFiles: WorkspaceFile[] = files.map((f, i) => ({
        id: i === 0 ? `${gid}-main` : generateUUID(),
        name: f.name,
        content: f.content,
        modified: false,
      }));
      fileGroups[gid] = wsFiles;
      const firstId = wsFiles[0]?.id ?? `${gid}-main`;
      activeGroupFileId[gid] = firstId;
      openGroupFileIds[gid] = wsFiles[0] ? [firstId] : [];
    }
    set((s) => {
      const activeGroupId = fileGroups[s.activeGroupId]
        ? s.activeGroupId
        : (Object.keys(fileGroups)[0] ?? s.activeGroupId);
      const groupFiles = fileGroups[activeGroupId] ?? [];
      return {
        fileGroups,
        activeGroupFileId,
        openGroupFileIds,
        activeGroupId,
        folderGroups: folders ?? {},
        // Mirror legacy flat fields to the active group
        files: groupFiles,
        activeFileId: activeGroupFileId[activeGroupId] ?? '',
        openFileIds: openGroupFileIds[activeGroupId] ?? [],
      };
    });
  },

  // ── Settings ──────────────────────────────────────────────────────────────

  setTheme: (theme) => set({ theme }),
  setFontSize: (fontSize) => set({ fontSize }),

  // Legacy: sets content of active file
  setCode: (code: string) => {
    const { activeFileId, setFileContent } = get();
    if (activeFileId) setFileContent(activeFileId, code);
  },
}));