/**
 * pi-git-hooks — Git Hook Manager
 * Install, list, and manage git hooks for any project.
 *
 * /hooks list              → list installed hooks
 * /hooks install <type>    → install a hook template
 * /hooks run <type>        → manually run a hook
 * /hooks templates         → show available templates
 */
import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
import { Type } from "@sinclair/typebox";
import { existsSync, readFileSync, writeFileSync, readdirSync, chmodSync } from "node:fs";
import { join } from "node:path";
import { execSync } from "node:child_process";
import { platform } from "node:os";

const RST = "\x1b[0m", B = "\x1b[1m", D = "\x1b[2m";
const G = "\x1b[32m", R = "\x1b[31m", Y = "\x1b[33m", C = "\x1b[36m";

const HOOK_TYPES = ["pre-commit", "commit-msg", "pre-push", "post-merge", "post-checkout", "prepare-commit-msg"];

const TEMPLATES: Record<string, { desc: string; script: string }> = {
  "pre-commit-lint": {
    desc: "Run linter before commit",
    script: `#!/bin/sh\nnpx --no-install eslint --max-warnings 0 . 2>/dev/null || { echo "Lint failed"; exit 1; }\n`,
  },
  "pre-commit-format": {
    desc: "Check formatting before commit",
    script: `#!/bin/sh\nnpx --no-install prettier --check . 2>/dev/null || { echo "Format check failed. Run: npx prettier --write ."; exit 1; }\n`,
  },
  "pre-commit-test": {
    desc: "Run tests before commit",
    script: `#!/bin/sh\nnpm test 2>/dev/null || { echo "Tests failed"; exit 1; }\n`,
  },
  "pre-commit-typecheck": {
    desc: "TypeScript type check before commit",
    script: `#!/bin/sh\nnpx --no-install tsc --noEmit 2>/dev/null || { echo "Type errors found"; exit 1; }\n`,
  },
  "commit-msg-conventional": {
    desc: "Enforce conventional commit messages (feat/fix/chore/...)",
    script: `#!/bin/sh\nMSG=$(cat "$1")\nif ! echo "$MSG" | grep -qE "^(feat|fix|chore|docs|style|refactor|perf|test|ci|build|revert)(\\(.+\\))?: .+"; then\n  echo "Commit message must follow conventional format:"\n  echo "  feat: add new feature"\n  echo "  fix: resolve bug"\n  echo "  chore: maintenance task"\n  exit 1\nfi\n`,
  },
  "commit-msg-length": {
    desc: "Enforce commit message length (max 72 chars first line)",
    script: `#!/bin/sh\nFIRST=$(head -1 "$1")\nif [ \${#FIRST} -gt 72 ]; then\n  echo "First line of commit message must be <= 72 chars (got \${#FIRST})"\n  exit 1\nfi\n`,
  },
  "pre-push-test": {
    desc: "Run full test suite before push",
    script: `#!/bin/sh\nnpm test 2>/dev/null || { echo "Tests failed — push aborted"; exit 1; }\n`,
  },
  "pre-push-build": {
    desc: "Verify build succeeds before push",
    script: `#!/bin/sh\nnpm run build 2>/dev/null || { echo "Build failed — push aborted"; exit 1; }\n`,
  },
};

function findGitDir(dir = "."): string | null {
  try {
    const out = execSync("git rev-parse --git-dir", { encoding: "utf-8", cwd: dir, timeout: 5000 }).trim();
    return out;
  } catch { return null; }
}

function listHooks(gitDir: string): { name: string; active: boolean; size: number }[] {
  const hooksDir = join(gitDir, "hooks");
  if (!existsSync(hooksDir)) return [];
  return readdirSync(hooksDir)
    .filter(f => !f.endsWith(".sample"))
    .map(f => {
      const content = readFileSync(join(hooksDir, f), "utf-8");
      return { name: f, active: content.trim().length > 0, size: content.length };
    });
}

export default function (pi: ExtensionAPI) {
  pi.registerCommand("hooks", {
    description: "Git hooks: /hooks list|install|run|templates",
    handler: async (args, ctx) => {
      const parts = (args || "").trim().split(/\s+/);
      const cmd = parts[0] || "list";

      const gitDir = findGitDir();
      if (!gitDir && cmd !== "templates") return `${R}Not in a git repository.${RST}`;

      if (cmd === "list") {
        const hooks = listHooks(gitDir!);
        if (!hooks.length) return `${Y}No hooks installed.${RST} Use /hooks install <template>`;
        let out = `${B}${C}🪝 Git Hooks${RST}\n\n`;
        for (const h of hooks) {
          out += `  ${h.active ? G + "●" : R + "○"}${RST} ${B}${h.name}${RST} ${D}(${h.size} bytes)${RST}\n`;
        }
        return out;
      }

      if (cmd === "templates") {
        let out = `${B}${C}📋 Hook Templates${RST}\n\n`;
        for (const [name, tmpl] of Object.entries(TEMPLATES)) {
          out += `  ${B}${name}${RST}\n    ${D}${tmpl.desc}${RST}\n`;
        }
        out += `\n${D}Install with: /hooks install <template-name>${RST}`;
        return out;
      }

      if (cmd === "install") {
        const template = parts[1];
        if (!template) return `${Y}Usage:${RST} /hooks install <template>\nRun /hooks templates to see options.`;
        const tmpl = TEMPLATES[template];
        if (!tmpl) return `${R}Unknown template:${RST} ${template}\nRun /hooks templates to see options.`;
        
        // Determine hook type from template name
        const hookType = template.replace(/-[^-]+$/, "").replace(/-/g, (_, i) => i === 0 ? "-" : "-");
        const actualType = HOOK_TYPES.find(h => template.startsWith(h)) || "pre-commit";
        
        const hooksDir = join(gitDir!, "hooks");
        const hookFile = join(hooksDir, actualType);
        
        if (existsSync(hookFile)) {
          const existing = readFileSync(hookFile, "utf-8");
          if (!existing.includes("# pi-hooks")) {
            // Append to existing hook
            writeFileSync(hookFile, existing + "\n# pi-hooks: " + template + "\n" + tmpl.script.split("\n").slice(1).join("\n"));
          } else {
            return `${Y}Hook ${actualType} already has pi-hooks content.${RST}`;
          }
        } else {
          writeFileSync(hookFile, "#!/bin/sh\n# pi-hooks: " + template + "\n" + tmpl.script.split("\n").slice(1).join("\n"));
        }
        
        if (platform() !== "win32") {
          try { chmodSync(hookFile, 0o755); } catch {}
        }
        
        return `${G}✅ Installed ${template} as ${actualType}${RST}\n  ${D}${tmpl.desc}${RST}`;
      }

      if (cmd === "run") {
        const hookType = parts[1];
        if (!hookType) return `${Y}Usage:${RST} /hooks run <hook-type>\nExample: /hooks run pre-commit`;
        const hookFile = join(gitDir!, "hooks", hookType);
        if (!existsSync(hookFile)) return `${R}Hook not found:${RST} ${hookType}`;
        try {
          const out = execSync(`sh "${hookFile}"`, { encoding: "utf-8", timeout: 30000 });
          return `${G}✅ ${hookType} passed${RST}\n${D}${out.trim()}${RST}`;
        } catch (e: any) {
          return `${R}✗ ${hookType} failed${RST}\n${e.stdout || ""}\n${e.stderr || ""}`;
        }
      }

      return `${B}${C}🪝 Git Hooks${RST}\n  /hooks list | templates | install <t> | run <type>`;
    }
  });

  pi.registerTool({
    name: "hooks_list",
    description: "List installed git hooks in the current repository.",
    parameters: Type.Object({}),
    execute: async () => {
      const gitDir = findGitDir();
      if (!gitDir) return "Not in a git repository.";
      return JSON.stringify(listHooks(gitDir), null, 2);
    }
  });

  pi.registerTool({
    name: "hooks_install",
    description: "Install a git hook template. Templates: pre-commit-lint, pre-commit-format, pre-commit-test, pre-commit-typecheck, commit-msg-conventional, commit-msg-length, pre-push-test, pre-push-build.",
    parameters: Type.Object({
      template: Type.String({ description: "Template name" }),
    }),
    execute: async (p) => {
      const tmpl = TEMPLATES[p.template];
      if (!tmpl) return "Unknown template: " + p.template + ". Available: " + Object.keys(TEMPLATES).join(", ");
      const gitDir = findGitDir();
      if (!gitDir) return "Not in a git repository.";
      const actualType = HOOK_TYPES.find(h => p.template.startsWith(h)) || "pre-commit";
      const hookFile = join(gitDir, "hooks", actualType);
      writeFileSync(hookFile, "#!/bin/sh\n# pi-hooks: " + p.template + "\n" + tmpl.script.split("\n").slice(1).join("\n"));
      if (platform() !== "win32") try { chmodSync(hookFile, 0o755); } catch {}
      return `Installed ${p.template} as ${actualType}`;
    }
  });
}