import * as fs from "fs/promises";

import { command, flag } from "cmd-ts";

import { select, spinner, log } from "@clack/prompts";

import * as path from "path";

import { loadConfig, loadState, saveState, findConfig } from "../lib/config";

import { loadCredentials, listCredentials, getCredentials } from "../lib/credentials";

import { createAgent, listDocuments } from "../lib/atproto";

import { scanContentDirectory, getContentHash, updateFrontmatterWithAtUri } from "../lib/markdown";

import { exitOnCancel } from "../lib/prompts";

export const syncCommand = command({

  name: "sync",

  description: "Sync state from ATProto to restore .sequoia-state.json",

  args: {

    updateFrontmatter: flag({

      long: "update-frontmatter",

      short: "u",

      description: "Update frontmatter atUri fields in local markdown files",

    }),

    dryRun: flag({

      long: "dry-run",

      short: "n",

      description: "Preview what would be synced without making changes",

    }),

  },

  handler: async ({ updateFrontmatter, dryRun }) => {

    // Load config

    const configPath = await findConfig();

    if (!configPath) {

      log.error("No sequoia.json found. Run 'sequoia init' first.");

      process.exit(1);

    }

    const config = await loadConfig(configPath);

    const configDir = path.dirname(configPath);

    log.info(`Site: ${config.siteUrl}`);

    log.info(`Publication: ${config.publicationUri}`);

    // Load credentials

    let credentials = await loadCredentials(config.identity);

    if (!credentials) {

      const identities = await listCredentials();

      if (identities.length === 0) {

        log.error("No credentials found. Run 'sequoia auth' first.");

        process.exit(1);

      }

      log.info("Multiple identities found. Select one to use:");

      const selected = exitOnCancel(await select({

        message: "Identity:",

        options: identities.map(id => ({ value: id, label: id })),

      }));

      credentials = await getCredentials(selected);

      if (!credentials) {

        log.error("Failed to load selected credentials.");

        process.exit(1);

      }

    }

    // Create agent

    const s = spinner();

    s.start(`Connecting to ${credentials.pdsUrl}...`);

    let agent;

    try {

      agent = await createAgent(credentials);

      s.stop(`Logged in as ${agent.session?.handle}`);

    } catch (error) {

      s.stop("Failed to login");

      log.error(`Failed to login: ${error}`);

      process.exit(1);

    }

    // Fetch documents from PDS

    s.start("Fetching documents from PDS...");

    const documents = await listDocuments(agent, config.publicationUri);

    s.stop(`Found ${documents.length} documents on PDS`);

    if (documents.length === 0) {

      log.info("No documents found for this publication.");

      return;

    }

    // Resolve content directory

    const contentDir = path.isAbsolute(config.contentDir)

      ? config.contentDir

      : path.join(configDir, config.contentDir);

    // Scan local posts

    s.start("Scanning local content...");

    const localPosts = await scanContentDirectory(contentDir, config.frontmatter);

    s.stop(`Found ${localPosts.length} local posts`);

    // Build a map of path -> local post for matching

    // Document path is like /posts/my-post-slug

    const postsByPath = new Map<string, typeof localPosts[0]>();

    for (const post of localPosts) {

      const postPath = `/posts/${post.slug}`;

      postsByPath.set(postPath, post);

    }

    // Load existing state

    const state = await loadState(configDir);

    const originalPostCount = Object.keys(state.posts).length;

    // Track changes

    let matchedCount = 0;

    let unmatchedCount = 0;

    let frontmatterUpdates: Array<{ filePath: string; atUri: string }> = [];

    log.message("\nMatching documents to local files:\n");

    for (const doc of documents) {

      const docPath = doc.value.path;

      const localPost = postsByPath.get(docPath);

      if (localPost) {

        matchedCount++;

        log.message(`  ✓ ${doc.value.title}`);

        log.message(`    Path: ${docPath}`);

        log.message(`    URI: ${doc.uri}`);

        log.message(`    File: ${path.basename(localPost.filePath)}`);

        // Update state (use relative path from config directory)

        const contentHash = await getContentHash(localPost.rawContent);

        const relativeFilePath = path.relative(configDir, localPost.filePath);

        state.posts[relativeFilePath] = {

          contentHash,

          atUri: doc.uri,

          lastPublished: doc.value.publishedAt,

        };

        // Check if frontmatter needs updating

        if (updateFrontmatter && localPost.frontmatter.atUri !== doc.uri) {

          frontmatterUpdates.push({

            filePath: localPost.filePath,

            atUri: doc.uri,

          });

          log.message(`    → Will update frontmatter`);

        }

      } else {

        unmatchedCount++;

        log.message(`  ✗ ${doc.value.title} (no matching local file)`);

        log.message(`    Path: ${docPath}`);

        log.message(`    URI: ${doc.uri}`);

      }

      log.message("");

    }

    // Summary

    log.message("---");

    log.info(`Matched: ${matchedCount} documents`);

    if (unmatchedCount > 0) {

      log.warn(`Unmatched: ${unmatchedCount} documents (exist on PDS but not locally)`);

    }

    if (dryRun) {

      log.info("\nDry run complete. No changes made.");

      return;

    }

    // Save updated state

    await saveState(configDir, state);

    const newPostCount = Object.keys(state.posts).length;

    log.success(`\nSaved .sequoia-state.json (${originalPostCount} → ${newPostCount} entries)`);

    // Update frontmatter if requested

    if (frontmatterUpdates.length > 0) {

      s.start(`Updating frontmatter in ${frontmatterUpdates.length} files...`);

      for (const { filePath, atUri } of frontmatterUpdates) {

        const content = await fs.readFile(filePath, "utf-8");

        const updated = updateFrontmatterWithAtUri(content, atUri);

        await fs.writeFile(filePath, updated);

        log.message(`  Updated: ${path.basename(filePath)}`);

      }

      s.stop("Frontmatter updated");

    }

    log.success("\nSync complete!");

  },

});