import { DurableObject } from "cloudflare:workers";

import { createFileDavDoDb, type FileDavDoDb } from "@/worker/db/file-dav-do/client";
import {
  abortWrite as abortWriteOp,
  beginWrite,
  commitWrite,
  copyNode,
  deleteNode,
  moveNodeEntry,
} from "@/worker/objects/file-dav/writes";
import { lock as lockOp, unlock as unlockOp } from "@/worker/objects/file-dav/locks";
import {
  cleanupExpiredLocks as cleanupExpiredLocksOp,
  cleanupExpiredPendingUploads as cleanupExpiredPendingUploadsOp,
  repairFileDav,
  verifyBlobUnreferenced as verifyBlobUnreferencedOp,
} from "@/worker/objects/file-dav/maintenance";
import {
  ensureInitialized as ensureInitializedOp,
  mkcol as mkcolOp,
  propfind as propfindOp,
  proppatch as proppatchOp,
  resolveFile as resolveFileOp,
} from "@/worker/objects/file-dav/properties";
import type {
  AbortWriteInput,
  BeginWriteInput,
  CleanupExpiredLocksInput,
  CleanupExpiredPendingUploadsInput,
  CommitWriteInput,
  CopyInput,
  DeleteInput,
  EnsureInitializedInput,
  FileDavRepairInput,
  LockInput,
  MkcolInput,
  MoveInput,
  PropfindInput,
  ProppatchInput,
  ResolveFileInput,
  UnlockInput,
  VerifyBlobUnreferencedInput,
} from "@/worker/objects/file-dav/types";
import { migrateFileDavObject } from "@/worker/objects/common/migrations";

export type {
  AbortWriteInput,
  BeginWriteInput,
  BeginWriteResult,
  BlobGcCandidate,
  CleanupExpiredLocksInput,
  CleanupExpiredPendingUploadsInput,
  CommitWriteInput,
  CommitWriteResult,
  CopyInput,
  DeleteInput,
  EnsureInitializedInput,
  FileDavRepairInput,
  FileDavError,
  FileDavErrorCode,
  FileDavNodeView,
  LockInput,
  MkcolInput,
  MoveInput,
  PropfindInput,
  ProppatchInput,
  ResolveFileInput,
  ResolveFileResult,
  SubjectInput,
  UnlockInput,
  VerifyBlobUnreferencedInput,
} from "@/worker/objects/file-dav/types";

export class FileDavObject extends DurableObject<Env> {
  readonly db: FileDavDoDb;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.db = createFileDavDoDb(ctx.storage);

    ctx.blockConcurrencyWhile(async () => {
      await migrateFileDavObject(this.db);
    });
  }

  async ping(): Promise<{ ok: true; object: "file-dav" }> {
    return { ok: true, object: "file-dav" };
  }

  async ensureInitialized(input: EnsureInitializedInput) {
    return ensureInitializedOp(this.db, input);
  }

  async propfind(input: PropfindInput) {
    return propfindOp(this.db, input);
  }

  async mkcol(input: MkcolInput) {
    return mkcolOp(this.db, input);
  }

  async proppatch(input: ProppatchInput) {
    return proppatchOp(this.db, input);
  }

  async beginWrite(input: BeginWriteInput) {
    return beginWrite(this.db, input);
  }

  async commitWrite(input: CommitWriteInput) {
    return commitWrite(this.db, input);
  }

  async abortWrite(input: AbortWriteInput) {
    return abortWriteOp(this.db, input);
  }

  async resolveFile(input: ResolveFileInput) {
    return resolveFileOp(this.db, input);
  }

  async delete(input: DeleteInput) {
    return deleteNode(this.db, input);
  }

  async copy(input: CopyInput) {
    return copyNode(this.db, input);
  }

  async move(input: MoveInput) {
    return moveNodeEntry(this.db, input);
  }

  async lock(input: LockInput) {
    return lockOp(this.db, input);
  }

  async unlock(input: UnlockInput) {
    return unlockOp(this.db, input);
  }

  async verifyBlobUnreferenced(input: VerifyBlobUnreferencedInput) {
    return verifyBlobUnreferencedOp(this.db, input);
  }

  async cleanupExpiredPendingUploads(input: CleanupExpiredPendingUploadsInput) {
    return cleanupExpiredPendingUploadsOp(this.db, input);
  }

  async cleanupExpiredLocks(input: CleanupExpiredLocksInput) {
    return cleanupExpiredLocksOp(this.db, input);
  }

  async repair(input: FileDavRepairInput) {
    return repairFileDav(this.db, input);
  }
}