import { NextResponse } from "next/server";
import { z } from "zod";

import { assertAgencyAdmin, getRouteAgencyContextOrThrow } from "@/lib/agency";
import { assertRateLimit } from "@/lib/api/rate-limit";
import { assertSameOrigin } from "@/lib/api/security";
import {
  suspendPleskSubscription,
  unsuspendPleskSubscription,
} from "@/lib/plesk/client";
import { createSupabaseRouteClient } from "@/lib/supabase/route";

const actionSchema = z.object({
  action: z.enum(["suspend", "unsuspend"]),
});

export async function POST(
  req: Request,
  { params }: { params: { id: string } },
) {
  const supabase = createSupabaseRouteClient() as any;
  let context: Awaited<ReturnType<typeof getRouteAgencyContextOrThrow>> | null =
    null;
  let domain: { id: string; subscription_id: string | null } | null = null;
  let subscription: { id: string; plesk_subscription_id: string } | null = null;
  let requestedAction: "suspend" | "unsuspend" | null = null;

  try {
    assertSameOrigin(req);

    context = await getRouteAgencyContextOrThrow();
    assertAgencyAdmin(context);
    assertRateLimit(`plesk-domain-action:${context.userId}`, 10, 60_000);

    const { action } = actionSchema.parse(await req.json());
    requestedAction = action;

    const { data: domainRow, error: domainError } = await supabase
      .from("plesk_domains")
      .select("id, agency_id, plesk_instance_id, subscription_id")
      .eq("id", params.id)
      .eq("agency_id", context.agencyId)
      .single();

    if (domainError || !domainRow) {
      throw new Error("Domain not found");
    }

    domain = {
      id: String(domainRow.id),
      subscription_id: domainRow.subscription_id
        ? String(domainRow.subscription_id)
        : null,
    };

    if (!domain.subscription_id) {
      throw new Error("Domain is not linked to a subscription");
    }

    const { data: subscriptionRow, error: subscriptionError } = await supabase
      .from("plesk_subscriptions")
      .select("id, plesk_subscription_id, plesk_instance_id")
      .eq("id", domain.subscription_id)
      .eq("agency_id", context.agencyId)
      .single();

    if (subscriptionError || !subscriptionRow) {
      throw new Error("Subscription not found");
    }

    subscription = {
      id: String(subscriptionRow.id),
      plesk_subscription_id: String(subscriptionRow.plesk_subscription_id),
    };

    const { data: instance, error: instanceError } = await supabase
      .from("plesk_instances")
      .select("id, base_url, auth_type, encrypted_secret")
      .eq("id", subscriptionRow.plesk_instance_id)
      .eq("agency_id", context.agencyId)
      .single();

    if (instanceError || !instance) {
      throw new Error("Plesk instance not found");
    }

    const connection = {
      baseUrl: instance.base_url,
      authType: instance.auth_type,
      encryptedSecret: instance.encrypted_secret,
    } as const;

    if (action === "suspend") {
      await suspendPleskSubscription(
        connection,
        subscription.plesk_subscription_id,
      );
    } else {
      await unsuspendPleskSubscription(
        connection,
        subscription.plesk_subscription_id,
      );
    }

    await supabase.from("actions_log").insert({
      agency_id: context.agencyId,
      actor_user_id: context.userId,
      target_type: "plesk_domain",
      target_id: domain.id,
      action: `domain_${action}`,
      status: "success",
      metadata: {
        domain_id: domain.id,
        subscription_id: subscription.id,
        plesk_subscription_id: subscription.plesk_subscription_id,
      },
    });

    return NextResponse.json({ ok: true });
  } catch (error) {
    if (context && domain) {
      const message =
        error instanceof Error ? error.message : "Domain action failed";
      await supabase.from("actions_log").insert({
        agency_id: context.agencyId,
        actor_user_id: context.userId,
        target_type: "plesk_domain",
        target_id: domain.id,
        action: requestedAction ? `domain_${requestedAction}` : "domain_action",
        status: "failed",
        error_message: message,
        metadata: {
          domain_id: domain.id,
          subscription_id: subscription?.id ?? domain.subscription_id,
          plesk_subscription_id: subscription?.plesk_subscription_id ?? null,
        },
      });
    }

    return NextResponse.json(
      {
        error: error instanceof Error ? error.message : "Domain action failed",
      },
      { status: 400 },
    );
  }
}