import { getMetaGraphBase } from "@/lib/env";
import { publicImageUrl } from "@/lib/social/meta-oauth";
import { withMetaAccessToken, withMetaAccessTokenBody } from "@/lib/social/meta-graph";
import {
  loadPublishableImageBuffer,
  resolvePublishableImageUrl,
} from "@/lib/social/publish-image";

export interface FacebookPublishResult {
  success: boolean;
  postId?: string;
  permalink?: string;
  error?: string;
  imageAttached?: boolean;
  imageSkipReason?: string;
}

async function publishFacebookPhotoBuffer(input: {
  pageId: string;
  pageAccessToken: string;
  caption: string;
  buffer: Buffer;
}): Promise<FacebookPublishResult> {
  const form = new FormData();
  form.append("source", new Blob([new Uint8Array(input.buffer)], { type: "image/png" }), "post.png");
  form.append("caption", input.caption.slice(0, 63206));
  form.append("access_token", input.pageAccessToken);

  const photoRes = await fetch(`${getMetaGraphBase()}/${input.pageId}/photos`, {
    method: "POST",
    body: form,
  });
  const photoData = (await photoRes.json()) as {
    id?: string;
    post_id?: string;
    error?: { message?: string };
  };

  if (photoRes.ok && (photoData.id || photoData.post_id)) {
    const postId = photoData.post_id ?? photoData.id;
    return {
      success: true,
      postId,
      permalink: postId ? `https://www.facebook.com/${postId}` : undefined,
      imageAttached: true,
    };
  }

  return {
    success: false,
    error: photoData.error?.message ?? "Facebook photo upload failed",
    imageAttached: false,
  };
}

async function publishFacebookPhotoUrl(input: {
  pageId: string;
  pageAccessToken: string;
  caption: string;
  imageUrl: string;
}): Promise<FacebookPublishResult> {
  const photoParams = withMetaAccessToken(input.pageAccessToken);
  photoParams.set("url", input.imageUrl);
  photoParams.set("caption", input.caption.slice(0, 63206));

  const photoRes = await fetch(
    `${getMetaGraphBase()}/${input.pageId}/photos?${photoParams.toString()}`,
    { method: "POST" },
  );
  const photoData = (await photoRes.json()) as {
    id?: string;
    post_id?: string;
    error?: { message?: string };
  };

  if (photoRes.ok && (photoData.id || photoData.post_id)) {
    const postId = photoData.post_id ?? photoData.id;
    return {
      success: true,
      postId,
      permalink: postId ? `https://www.facebook.com/${postId}` : undefined,
      imageAttached: true,
    };
  }

  return {
    success: false,
    error: photoData.error?.message ?? "Facebook photo upload failed",
    imageAttached: false,
  };
}

export async function publishToFacebook(input: {
  pageId: string;
  pageAccessToken: string;
  caption: string;
  imageUrl?: string | null;
  appOrigin: string;
}): Promise<FacebookPublishResult> {
  try {
    if (input.imageUrl) {
      const buffer = await loadPublishableImageBuffer(input.imageUrl, input.appOrigin);
      if (buffer) {
        const bufferResult = await publishFacebookPhotoBuffer({
          pageId: input.pageId,
          pageAccessToken: input.pageAccessToken,
          caption: input.caption,
          buffer,
        });
        if (bufferResult.success) {
          return bufferResult;
        }
      }

      const publishUrl = await resolvePublishableImageUrl(input.imageUrl, input.appOrigin);
      const image = publicImageUrl(publishUrl, input.appOrigin);
      if (image && !image.includes(".svg")) {
        const urlResult = await publishFacebookPhotoUrl({
          pageId: input.pageId,
          pageAccessToken: input.pageAccessToken,
          caption: input.caption,
          imageUrl: image,
        });
        if (urlResult.success) {
          return urlResult;
        }

        const photoError = urlResult.error;
        if (photoError && !photoError.toLowerCase().includes("duplicate")) {
          return {
            success: false,
            error: photoError,
            imageAttached: false,
            imageSkipReason: buffer
              ? "Facebook rejected the image upload."
              : "Facebook could not fetch the image URL.",
          };
        }
      }
    }

    const body = withMetaAccessTokenBody(input.pageAccessToken, {
      message: input.caption.slice(0, 63206),
    });

    const res = await fetch(`${getMetaGraphBase()}/${input.pageId}/feed`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body),
    });

    const data = (await res.json()) as { id?: string; error?: { message?: string } };
    if (!res.ok || !data.id) {
      return { success: false, error: data.error?.message ?? "Facebook publish failed" };
    }

    return {
      success: true,
      postId: data.id,
      permalink: `https://www.facebook.com/${data.id}`,
      imageAttached: false,
      imageSkipReason: input.imageUrl
        ? "Posted as text only — image upload failed or was skipped."
        : undefined,
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : "Facebook publish failed",
      imageAttached: false,
    };
  }
}