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, createDocument, updateDocument, uploadImage, resolveImagePath, createBlueskyPost, addBskyPostRefToDocument } from "../lib/atproto";
import {
  scanContentDirectory,
  getContentHash,
  updateFrontmatterWithAtUri,
} from "../lib/markdown";
import type { BlogPost, BlobObject, StrongRef } from "../lib/types";
import { exitOnCancel } from "../lib/prompts";

export const publishCommand = command({
  name: "publish",
  description: "Publish content to ATProto",
  args: {
    force: flag({
      long: "force",
      short: "f",
      description: "Force publish all posts, ignoring change detection",
    }),
    dryRun: flag({
      long: "dry-run",
      short: "n",
      description: "Preview what would be published without making changes",
    }),
  },
  handler: async ({ force, dryRun }) => {
    // Load config
    const configPath = await findConfig();
    if (!configPath) {
      log.error("No publisher.config.ts found. Run 'publisher init' first.");
      process.exit(1);
    }

    const config = await loadConfig(configPath);
    const configDir = path.dirname(configPath);

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

    // Load credentials
    let credentials = await loadCredentials(config.identity);

    // If no credentials resolved, check if we need to prompt for identity selection
    if (!credentials) {
      const identities = await listCredentials();
      if (identities.length === 0) {
        log.error("No credentials found. Run 'sequoia auth' first.");
        log.info("Or set ATP_IDENTIFIER and ATP_APP_PASSWORD environment variables.");
        process.exit(1);
      }

      // Multiple identities exist but none selected - prompt user
      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);
      }

      log.info(`Tip: Add "identity": "${selected}" to sequoia.json to use this by default.`);
    }

    // Resolve content directory
    const contentDir = path.isAbsolute(config.contentDir)
      ? config.contentDir
      : path.join(configDir, config.contentDir);

    const imagesDir = config.imagesDir
      ? path.isAbsolute(config.imagesDir)
        ? config.imagesDir
        : path.join(configDir, config.imagesDir)
      : undefined;

    // Load state
    const state = await loadState(configDir);

    // Scan for posts
    const s = spinner();
    s.start("Scanning for posts...");
    const posts = await scanContentDirectory(contentDir, config.frontmatter, config.ignore);
    s.stop(`Found ${posts.length} posts`);

    // Determine which posts need publishing
    const postsToPublish: Array<{
      post: BlogPost;
      action: "create" | "update";
      reason: string;
    }> = [];
    const draftPosts: BlogPost[] = [];

    for (const post of posts) {
      // Skip draft posts
      if (post.frontmatter.draft) {
        draftPosts.push(post);
        continue;
      }

      const contentHash = await getContentHash(post.rawContent);
      const relativeFilePath = path.relative(configDir, post.filePath);
      const postState = state.posts[relativeFilePath];

      if (force) {
        postsToPublish.push({
          post,
          action: post.frontmatter.atUri ? "update" : "create",
          reason: "forced",
        });
      } else if (!postState) {
        // New post
        postsToPublish.push({
          post,
          action: "create",
          reason: "new post",
        });
      } else if (postState.contentHash !== contentHash) {
        // Changed post
        postsToPublish.push({
          post,
          action: post.frontmatter.atUri ? "update" : "create",
          reason: "content changed",
        });
      }
    }

    if (draftPosts.length > 0) {
      log.info(`Skipping ${draftPosts.length} draft post${draftPosts.length === 1 ? "" : "s"}`);
    }

    if (postsToPublish.length === 0) {
      log.success("All posts are up to date. Nothing to publish.");
      return;
    }

    log.info(`\n${postsToPublish.length} posts to publish:\n`);

    // Bluesky posting configuration
    const blueskyEnabled = config.bluesky?.enabled ?? false;
    const maxAgeDays = config.bluesky?.maxAgeDays ?? 7;
    const cutoffDate = new Date();
    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);

    for (const { post, action, reason } of postsToPublish) {
      const icon = action === "create" ? "+" : "~";
      const relativeFilePath = path.relative(configDir, post.filePath);
      const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;

      let bskyNote = "";
      if (blueskyEnabled) {
        if (existingBskyPostRef) {
          bskyNote = " [bsky: exists]";
        } else {
          const publishDate = new Date(post.frontmatter.publishDate);
          if (publishDate < cutoffDate) {
            bskyNote = ` [bsky: skipped, older than ${maxAgeDays} days]`;
          } else {
            bskyNote = " [bsky: will post]";
          }
        }
      }

      log.message(`  ${icon} ${post.frontmatter.title} (${reason})${bskyNote}`);
    }

    if (dryRun) {
      if (blueskyEnabled) {
        log.info(`\nBluesky posting: enabled (max age: ${maxAgeDays} days)`);
      }
      log.info("\nDry run complete. No changes made.");
      return;
    }

    // Create agent
    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);
    }

    // Publish posts
    let publishedCount = 0;
    let updatedCount = 0;
    let errorCount = 0;
    let bskyPostCount = 0;

    for (const { post, action } of postsToPublish) {
      s.start(`Publishing: ${post.frontmatter.title}`);

      try {
        // Handle cover image upload
        let coverImage: BlobObject | undefined;
        if (post.frontmatter.ogImage) {
          const imagePath = await resolveImagePath(
            post.frontmatter.ogImage,
            imagesDir,
            contentDir
          );

          if (imagePath) {
            log.info(`  Uploading cover image: ${path.basename(imagePath)}`);
            coverImage = await uploadImage(agent, imagePath);
            if (coverImage) {
              log.info(`  Uploaded image blob: ${coverImage.ref.$link}`);
            }
          } else {
            log.warn(`  Cover image not found: ${post.frontmatter.ogImage}`);
          }
        }

        // Track atUri, content for state saving, and bskyPostRef
        let atUri: string;
        let contentForHash: string;
        let bskyPostRef: StrongRef | undefined;
        const relativeFilePath = path.relative(configDir, post.filePath);

        // Check if bskyPostRef already exists in state
        const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;

        if (action === "create") {
          atUri = await createDocument(agent, post, config, coverImage);
          s.stop(`Created: ${atUri}`);

          // Update frontmatter with atUri
          const updatedContent = updateFrontmatterWithAtUri(post.rawContent, atUri);
          await fs.writeFile(post.filePath, updatedContent);
          log.info(`  Updated frontmatter in ${path.basename(post.filePath)}`);

          // Use updated content (with atUri) for hash so next run sees matching hash
          contentForHash = updatedContent;
          publishedCount++;
        } else {
          atUri = post.frontmatter.atUri!;
          await updateDocument(agent, post, atUri, config, coverImage);
          s.stop(`Updated: ${atUri}`);

          // For updates, rawContent already has atUri
          contentForHash = post.rawContent;
          updatedCount++;
        }

        // Create Bluesky post if enabled and conditions are met
        if (blueskyEnabled) {
          if (existingBskyPostRef) {
            log.info(`  Bluesky post already exists, skipping`);
            bskyPostRef = existingBskyPostRef;
          } else {
            const publishDate = new Date(post.frontmatter.publishDate);

            if (publishDate < cutoffDate) {
              log.info(`  Post is older than ${maxAgeDays} days, skipping Bluesky post`);
            } else {
              // Create Bluesky post
              try {
                const pathPrefix = config.pathPrefix || "/posts";
                const canonicalUrl = `${config.siteUrl}${pathPrefix}/${post.slug}`;

                bskyPostRef = await createBlueskyPost(agent, {
                  title: post.frontmatter.title,
                  description: post.frontmatter.description,
                  canonicalUrl,
                  coverImage,
                  publishedAt: post.frontmatter.publishDate,
                });

                // Update document record with bskyPostRef
                await addBskyPostRefToDocument(agent, atUri, bskyPostRef);
                log.info(`  Created Bluesky post: ${bskyPostRef.uri}`);
                bskyPostCount++;
              } catch (bskyError) {
                const errorMsg = bskyError instanceof Error ? bskyError.message : String(bskyError);
                log.warn(`  Failed to create Bluesky post: ${errorMsg}`);
              }
            }
          }
        }

        // Update state (use relative path from config directory)
        const contentHash = await getContentHash(contentForHash);
        state.posts[relativeFilePath] = {
          contentHash,
          atUri,
          lastPublished: new Date().toISOString(),
          bskyPostRef,
        };
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        s.stop(`Error publishing "${path.basename(post.filePath)}"`);
        log.error(`  ${errorMessage}`);
        errorCount++;
      }
    }

    // Save state
    await saveState(configDir, state);

    // Summary
    log.message("\n---");
    log.info(`Published: ${publishedCount}`);
    log.info(`Updated: ${updatedCount}`);
    if (bskyPostCount > 0) {
      log.info(`Bluesky posts: ${bskyPostCount}`);
    }
    if (errorCount > 0) {
      log.warn(`Errors: ${errorCount}`);
    }
  },
});