import { mkdir, rm, writeFile } from "node:fs/promises"
import path from "node:path"
import { execFile } from "node:child_process"
import { promisify } from "node:util"
import type { Workspace } from "../domain/types"
import type { NodepadStore } from "../persistence/store"
import { restoreSerialized, serializeWorkspace, snapshotContainsSecrets, type SerializedWorkspace } from "./serialization"
import { contentHash } from "../domain/id"
const exec = promisify(execFile)

export interface PushResult { commitSha: string; skipped?: boolean; conflict?: boolean; status?: "completed" | "clean" | "sync_conflict" }
export interface BackupRemote { status(): Promise<{ configured: boolean; detail: string }>; pushWorkspace(snapshot: SerializedWorkspace): Promise<PushResult>; listSnapshots(workspaceId: string): Promise<{ ref: string }[]>; restoreWorkspace(workspaceId: string, ref: string): Promise<SerializedWorkspace> }

export class LocalGitBackup implements BackupRemote {
  constructor(private repo = process.env.NODEPAD_BACKUP_REPO || path.join(process.cwd(), "data", "backups"), private base = process.env.NODEPAD_GITHUB_PATH || "nodepad-workspaces") {}
  async status() { return { configured: true, detail: this.repo } }
  async pushWorkspace(snapshot: SerializedWorkspace): Promise<PushResult> {
    await mkdir(this.repo, { recursive: true }); try { await exec("git", ["init", "-q"], { cwd: this.repo }) } catch {}
    const root = path.join(this.repo, this.base, snapshot.workspaceId); await rm(root, { recursive: true, force: true })
    for (const [name, value] of Object.entries(snapshot.files)) { const file = path.join(root, name); await mkdir(path.dirname(file), { recursive: true }); await writeFile(file, value) }
    await exec("git", ["add", "--", this.base], { cwd: this.repo })
    const dirty = await exec("git", ["diff", "--cached", "--quiet"], { cwd: this.repo }).then(() => false).catch(() => true)
    if (!dirty) return { commitSha: (await exec("git", ["rev-parse", "HEAD"], { cwd: this.repo })).stdout.trim(), skipped: true, status: "clean" }
    await exec("git", ["-c", "user.name=Nodepad", "-c", "user.email=nodepad@localhost", "commit", "-m", `nodepad(${snapshot.workspaceId}): backup`], { cwd: this.repo })
    return { commitSha: (await exec("git", ["rev-parse", "HEAD"], { cwd: this.repo })).stdout.trim(), status: "completed" }
  }
  async listSnapshots() { try { return (await exec("git", ["log", "--format=%H"], { cwd: this.repo })).stdout.trim().split("\n").filter(Boolean).map(ref => ({ ref })) } catch { return [] } }
  async restoreWorkspace(id: string, ref: string): Promise<SerializedWorkspace> { const files = (await exec("git", ["ls-tree", "-r", "--name-only", ref, "--", `${this.base}/${id}`], { cwd: this.repo })).stdout.trim().split("\n").filter(Boolean); const output: Record<string, string> = {}; for (const file of files) output[path.relative(path.join(this.base, id), file)] = (await exec("git", ["show", `${ref}:${file}`], { cwd: this.repo, maxBuffer: 20_000_000 })).stdout; return { workspaceId: id, schemaVersion: 1, files: output } }
}

interface GitHubOptions { token: string; repository: string; branch: string; basePath: string; allowCreateBranch?: boolean; fetchImpl?: typeof fetch }
export class GitHubBackupRemote implements BackupRemote {
  private fetchImpl: typeof fetch
  constructor(private options: GitHubOptions) { this.fetchImpl = options.fetchImpl ?? fetch }
  static fromEnv(fetchImpl?: typeof fetch) {
    const token = process.env.NODEPAD_GITHUB_TOKEN, repository = process.env.NODEPAD_GITHUB_REPOSITORY
    if (!token || !repository) throw new Error("NODEPAD_GITHUB_TOKEN and NODEPAD_GITHUB_REPOSITORY are required")
    return new GitHubBackupRemote({ token, repository, branch: process.env.NODEPAD_GITHUB_BRANCH || "nodepad-backup", basePath: process.env.NODEPAD_GITHUB_PATH || "nodepad-workspaces", allowCreateBranch: process.env.NODEPAD_GITHUB_CREATE_BRANCH !== "false", fetchImpl })
  }
  private async request(route: string, init: RequestInit = {}, allow404 = false): Promise<any> {
    const response = await this.fetchImpl(`https://api.github.com/repos/${this.options.repository}${route}`, { ...init, headers: { Accept: "application/vnd.github+json", Authorization: `Bearer ${this.options.token}`, "X-GitHub-Api-Version": "2022-11-28", "Content-Type": "application/json", ...init.headers } })
    if (allow404 && response.status === 404) return null
    if (!response.ok) { const body = await response.text(); const error = new Error(`GitHub ${response.status}: ${body}`) as Error & { status?: number }; error.status = response.status; throw error }
    return response.status === 204 ? null : response.json()
  }
  async status() { return { configured: Boolean(this.options.token && this.options.repository), detail: `${this.options.repository}#${this.options.branch}` } }
  private async branchHead() { const ref = await this.request(`/git/ref/heads/${encodeURIComponent(this.options.branch)}`, {}, true); return ref?.object?.sha as string | undefined }
  private async baseHead() { const repository = await this.request(""); const ref = await this.request(`/git/ref/heads/${encodeURIComponent(repository.default_branch)}`); return ref.object.sha as string }
  async pushWorkspace(snapshot: SerializedWorkspace): Promise<PushResult> {
    if (snapshotContainsSecrets(snapshot)) throw new Error("Snapshot contains secret-like content")
    const expectedHead = await this.branchHead(), branchMissing = !expectedHead
    if (branchMissing && this.options.allowCreateBranch === false) throw new Error(`Backup branch ${this.options.branch} does not exist`)
    const parent = expectedHead ?? await this.baseHead(), parentCommit = await this.request(`/git/commits/${parent}`)
    const prefix = `${this.options.basePath}/${snapshot.workspaceId}/`
    const entries: Array<{ path: string; mode: string; type: string; sha: string | null }> = await Promise.all(Object.entries(snapshot.files).sort(([a], [b]) => a.localeCompare(b)).map(async ([name, content]) => {
      const blob = await this.request("/git/blobs", { method: "POST", body: JSON.stringify({ content, encoding: "utf-8" }) })
      return { path: `${prefix}${name}`, mode: "100644", type: "blob", sha: blob.sha }
    }))
    const parentTree = await this.request(`/git/trees/${parentCommit.tree.sha}?recursive=1`)
    const desired = new Set(entries.map(entry => entry.path))
    for (const previous of parentTree.tree.filter((entry: any) => entry.type === "blob" && entry.path.startsWith(prefix))) {
      if (!desired.has(previous.path)) entries.push({ path: previous.path, mode: "100644", type: "blob", sha: null })
    }
    const tree = await this.request("/git/trees", { method: "POST", body: JSON.stringify({ base_tree: parentCommit.tree.sha, tree: entries }) })
    if (tree.sha === parentCommit.tree.sha) return { commitSha: parent, skipped: true, status: "clean" }
    const commit = await this.request("/git/commits", { method: "POST", body: JSON.stringify({ message: `nodepad(${snapshot.workspaceId}): backup`, tree: tree.sha, parents: [parent] }) })
    const currentHead = await this.branchHead()
    if ((!branchMissing && currentHead !== expectedHead) || (branchMissing && currentHead)) return { commitSha: currentHead ?? parent, conflict: true, status: "sync_conflict" }
    try {
      if (branchMissing) await this.request("/git/refs", { method: "POST", body: JSON.stringify({ ref: `refs/heads/${this.options.branch}`, sha: commit.sha }) })
      else await this.request(`/git/refs/heads/${encodeURIComponent(this.options.branch)}`, { method: "PATCH", body: JSON.stringify({ sha: commit.sha, force: false }) })
    } catch (error) {
      if ((error as Error & { status?: number }).status === 409 || (error as Error & { status?: number }).status === 422) return { commitSha: expectedHead ?? parent, conflict: true, status: "sync_conflict" }
      throw error
    }
    return { commitSha: commit.sha, status: "completed" }
  }
  async listSnapshots(workspaceId: string) { const commits = await this.request(`/commits?sha=${encodeURIComponent(this.options.branch)}&path=${encodeURIComponent(`${this.options.basePath}/${workspaceId}`)}&per_page=100`, {}, true); return (commits ?? []).map((commit: any) => ({ ref: commit.sha })) }
  async restoreWorkspace(workspaceId: string, ref: string): Promise<SerializedWorkspace> {
    const commit = await this.request(`/git/commits/${encodeURIComponent(ref)}`), tree = await this.request(`/git/trees/${commit.tree.sha}?recursive=1`)
    const prefix = `${this.options.basePath}/${workspaceId}/`, files: Record<string, string> = {}
    for (const entry of tree.tree.filter((item: any) => item.type === "blob" && item.path.startsWith(prefix))) { const blob = await this.request(`/git/blobs/${entry.sha}`); files[entry.path.slice(prefix.length)] = Buffer.from(blob.content.replace(/\n/g, ""), blob.encoding === "base64" ? "base64" : "utf8").toString("utf8") }
    return { workspaceId, schemaVersion: 1, files }
  }
}

export const configuredBackupRemote = () => {
  if (process.env.NODEPAD_GITHUB_TOKEN && process.env.NODEPAD_GITHUB_REPOSITORY) return GitHubBackupRemote.fromEnv()
  if (process.env.NODEPAD_BACKUP_REPO) return new LocalGitBackup()
  throw new Error("backup_not_configured")
}
export async function backupWorkspace(workspace: Workspace, remote: BackupRemote = configuredBackupRemote()) { const snapshotHash=contentHash({nodes:workspace.nodes,edges:workspace.edges,evidence:workspace.evidence,hypotheses:workspace.hypotheses,syntheses:workspace.syntheses,researchTasks:workspace.researchTasks,researchResults:workspace.researchResults,brain:workspace.brain});if(workspace.backup?.snapshotHash===snapshotHash)return{commitSha:workspace.backup.lastCommitSha??"unchanged",skipped:true,status:"clean" as const,snapshotHash};const minimum = Number(process.env.NODEPAD_GITHUB_MIN_COMMIT_INTERVAL_SECONDS ?? 600) * 1000; if(workspace.backup?.lastBackupAt&&Date.now()-Date.parse(workspace.backup.lastBackupAt)<minimum)return{commitSha:workspace.backup.lastCommitSha??"debounced",skipped:true,status:"clean" as const,snapshotHash};return{...await remote.pushWorkspace(serializeWorkspace(workspace)),snapshotHash} }
export async function stageRestore(store: NodepadStore, remote: BackupRemote, id: string, ref: string, newId = `${id}-restored-${Date.now()}`) { const snapshot = await remote.restoreWorkspace(id, ref); const staged = restoreSerialized(snapshot, newId); await store.saveWorkspace(staged); return staged }