// actions/google-ads.ts
"use server";

import { createClient } from "@/utils/supabase/server";
import { GoogleAdsApi } from "google-ads-api";
import { revalidatePath } from "next/cache";
import { z } from "zod";

const campaignSchema = z.object({
  name: z.string().min(1),
  budget: z.number().positive(),
  status: z.enum(["ENABLED", "PAUSED"]),
});

export async function createCampaign(prevState: any, formData: FormData) {
  try {
    const supabase = await createClient();
    const {
      data: { user },
    } = await supabase.auth.getUser();

    if (!user) {
      return { error: "Authentication required" };
    }

    // Get OAuth tokens from Supabase
    const { data: tokenData } = await supabase
      .from("oauth_tokens")
      .select("*")
      .eq("user_id", user.id)
      .eq("provider", "google")
      .single();

    if (!tokenData) {
      return { error: "Google OAuth token not found" };
    }

    // Validate form data
    const validatedFields = campaignSchema.safeParse({
      name: formData.get("name"),
      budget: Number(formData.get("budget")),
      status: formData.get("status"),
    });

    if (!validatedFields.success) {
      return {
        error: "Invalid form data",
        fieldErrors: validatedFields.error.flatten().fieldErrors,
      };
    }

    // Initialize Google Ads API client
    const client = new GoogleAdsApi({
      client_id: process.env.GOOGLE_CLIENT_ID!,
      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
      developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!,
    });

    const customer = client.Customer({
      customer_id: process.env.GOOGLE_ADS_CUSTOMER_ID!,
      refresh_token: tokenData.refresh_token,
    });

    // Create campaign logic here...

    revalidatePath("/campaigns");
    return { success: true };
  } catch (error) {
    console.error("Campaign creation error:", error);
    return { error: "Failed to create campaign" };
  }
}

// middleware.ts
import { createServerClient } from "@supabase/ssr";
import { NextResponse, type NextRequest } from "next/server";

export async function middleware(request: NextRequest) {
  let supabaseResponse = NextResponse.next({
    request,
  });

  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return request.cookies.getAll();
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value }) =>
            request.cookies.set(name, value),
          );
          supabaseResponse = NextResponse.next({
            request,
          });
          cookiesToSet.forEach(({ name, value, options }) =>
            supabaseResponse.cookies.set(name, value, options),
          );
        },
      },
    },
  );

  // Refresh session if expired
  await supabase.auth.getUser();

  return supabaseResponse;
}

// container/container.ts
import { Container } from "inversify";
import { TYPES } from "./types";
import { GoogleAdsRepository } from "../infrastructure/repositories/GoogleAdsRepository";
import { CampaignUseCase } from "../core/usecases/CampaignUseCase";

const container = new Container();

// Repository bindings
container.bind(TYPES.GoogleAdsRepository).to(GoogleAdsRepository);

// Use case bindings
container.bind(TYPES.CampaignUseCase).to(CampaignUseCase);

export { container };

// core/ports/IGoogleAdsRepository.ts
export interface IGoogleAdsRepository {
  getCampaigns(customerId: string): Promise<Campaign[]>;
  getCampaignById(
    customerId: string,
    campaignId: string,
  ): Promise<Campaign | null>;
  createCampaign(
    customerId: string,
    campaign: CreateCampaignRequest,
  ): Promise<Campaign>;
  updateCampaign(
    customerId: string,
    campaignId: string,
    updates: UpdateCampaignRequest,
  ): Promise<Campaign>;
}

// infrastructure/repositories/GoogleAdsRepository.ts
import { injectable, inject } from "inversify";
import { GoogleAdsApi } from "google-ads-api";
import { IGoogleAdsRepository } from "../../core/ports/IGoogleAdsRepository";

@injectable()
export class GoogleAdsRepository implements IGoogleAdsRepository {
  private client: GoogleAdsApi;

  constructor(@inject(TYPES.Logger) private logger: ILogger) {
    this.client = new GoogleAdsApi({
      client_id: process.env.GOOGLE_ADS_CLIENT_ID!,
      client_secret: process.env.GOOGLE_ADS_CLIENT_SECRET!,
      developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!,
    });
  }

  async getCampaigns(customerId: string): Promise<Campaign[]> {
    // Implementation...
  }
}

// shared/types/google-ads.ts
export interface Campaign {
  id: string;
  name: string;
  status: CampaignStatus;
  channelType: AdvertisingChannelType;
  budget?: Budget;
  metrics?: CampaignMetrics;
}

export interface CampaignMetrics {
  impressions: number;
  clicks: number;
  cost: number;
  conversions: number;
  ctr: number;
  cpc: number;
}

export enum CampaignStatus {
  ENABLED = "ENABLED",
  PAUSED = "PAUSED",
  REMOVED = "REMOVED",
}

// presentation/components/campaign/CampaignDashboard.tsx
'use client'

import React from 'react';
import { useQuery } from '@tanstack/react-query';
import { CampaignTable } from './CampaignTable';
import { useCampaignDashboard } from '../../hooks/useCampaignDashboard';

interface CampaignDashboardProps {
  customerId: string;
  dateRange: DateRange;
}

export const CampaignDashboard: React.FC<CampaignDashboardProps> = ({
  customerId,
  dateRange,
}) => {
  const {
    data: dashboardData,
    isLoading,
    error,
    refetch,
  } = useCampaignDashboard(customerId, dateRange);

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div className="space-y-6">
      <CampaignTable campaigns={dashboardData.campaigns} />
    </div>
  );
};

// actions/campaign-toggle.ts
"use server";

import { GoogleAdsApi, enums } from "google-ads-api";
import { createClient } from "@/utils/supabase/server";
import { revalidatePath } from "next/cache";

export async function toggleCampaignStatus(
  campaignId: string,
  currentStatus: string,
) {
  try {
    // 1. 사용자 인증 확인
    const supabase = await createClient();
    const {
      data: { user },
    } = await supabase.auth.getUser();

    if (!user) {
      return { error: "Authentication required" };
    }

    // 2. OAuth 토큰 가져오기
    const { data: tokenData } = await supabase
      .from("oauth_tokens")
      .select("refresh_token")
      .eq("user_id", user.id)
      .eq("provider", "google")
      .single();

    if (!tokenData) {
      return { error: "Google OAuth token not found" };
    }

    // 3. Google Ads API 클라이언트 초기화
    const client = new GoogleAdsApi({
      client_id: process.env.GOOGLE_CLIENT_ID!,
      client_secret: process.env.GOOGLE_CLIENT_SECRET!,
      developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!,
    });

    const customer = client.Customer({
      customer_id: process.env.GOOGLE_ADS_CUSTOMER_ID!,
      refresh_token: tokenData.refresh_token,
    });

    // 4. 새로운 상태 결정 (토글)
    const newStatus =
      currentStatus === "ENABLED"
        ? enums.CampaignStatus.PAUSED
        : enums.CampaignStatus.ENABLED;

    // 5. 캠페인 상태 업데이트
    const campaignResourceName = `customers/${process.env.GOOGLE_ADS_CUSTOMER_ID}/campaigns/${campaignId}`;

    await customer.mutateResources([
      {
        entity: "campaign",
        operation: "update",
        resource_name: campaignResourceName,
        resource: {
          resource_name: campaignResourceName,
          status: newStatus,
        },
        update_mask: ["status"],
      },
    ]);

    // 6. 캐시 무효화
    revalidatePath("/campaigns");

    return {
      success: true,
      newStatus:
        newStatus === enums.CampaignStatus.ENABLED ? "ENABLED" : "PAUSED",
    };
  } catch (error) {
    console.error("Failed to toggle campaign status:", error);
    return { error: "Failed to update campaign status" };
  }
}

// components/campaign/CampaignToggle.tsx
'use client'

import React, { useState } from 'react';
import { toggleCampaignStatus } from '@/actions/campaign-toggle';

interface CampaignToggleProps {
  campaignId: string;
  initialStatus: 'ENABLED' | 'PAUSED';
  campaignName: string;
}

export function CampaignToggle({
  campaignId,
  initialStatus,
  campaignName
}: CampaignToggleProps) {
  const [status, setStatus] = useState(initialStatus);
  const [isLoading, setIsLoading] = useState(false);

  const handleToggle = async () => {
    setIsLoading(true);

    try {
      const result = await toggleCampaignStatus(campaignId, status);

      if (result.success && result.newStatus) {
        setStatus(result.newStatus as 'ENABLED' | 'PAUSED');
        // Show success toast
        toast.success(`Campaign ${result.newStatus === 'ENABLED' ? 'enabled' : 'paused'}`);
      } else if (result.error) {
        // Show error toast
        toast.error(result.error);
      }
    } catch (error) {
      toast.error('An unexpected error occurred');
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <div className="flex items-center space-x-2">
      <span className="text-sm text-gray-600">
        {campaignName}
      </span>
      <button
        onClick={handleToggle}
        disabled={isLoading}
        className={`
          relative inline-flex h-6 w-11 items-center rounded-full
          ${status === 'ENABLED' ? 'bg-green-600' : 'bg-gray-300'}
          ${isLoading ? 'opacity-50 cursor-not-allowed' : 'cursor-pointer'}
          transition-colors duration-200 ease-in-out
        `}
        aria-label={`Toggle campaign ${campaignName}`}
      >
        <span
          className={`
            inline-block h-4 w-4 transform rounded-full bg-white
            transition-transform duration-200 ease-in-out
            ${status === 'ENABLED' ? 'translate-x-6' : 'translate-x-1'}
          `}
        />
      </button>
      <span className="text-xs text-gray-500">
        {status === 'ENABLED' ? 'Active' : 'Paused'}
      </span>
    </div>
  );
}

// app/(dashboard)/campaigns/page.tsx
import { getCampaigns } from '@/actions/google-ads';
import { CampaignToggle } from '@/components/campaign/CampaignToggle';

export default async function CampaignsPage() {
  const campaigns = await getCampaigns();

  return (
    <div className="container mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">Campaign Management</h1>

      <div className="bg-white rounded-lg shadow">
        <table className="min-w-full divide-y divide-gray-200">
          <thead className="bg-gray-50">
            <tr>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                Campaign Name
              </th>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                Status
              </th>
              <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                Actions
              </th>
            </tr>
          </thead>
          <tbody className="bg-white divide-y divide-gray-200">
            {campaigns.map((campaign) => (
              <tr key={campaign.id}>
                <td className="px-6 py-4 whitespace-nowrap">
                  {campaign.name}
                </td>
                <td className="px-6 py-4 whitespace-nowrap">
                  <span className={`px-2 inline-flex text-xs leading-5 font-semibold rounded-full ${
                    campaign.status === 'ENABLED'
                      ? 'bg-green-100 text-green-800'
                      : 'bg-gray-100 text-gray-800'
                  }`}>
                    {campaign.status}
                  </span>
                </td>
                <td className="px-6 py-4 whitespace-nowrap">
                  <CampaignToggle
                    campaignId={campaign.id}
                    initialStatus={campaign.status}
                    campaignName={campaign.name}
                  />
                </td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
    </div>
  );
}

// utils/error-handler.ts
export class GoogleAdsError extends Error {
  constructor(
    message: string,
    public code?: string,
    public details?: any,
  ) {
    super(message);
    this.name = "GoogleAdsError";
  }
}

export function handleGoogleAdsError(error: any): GoogleAdsError {
  if (error.errors && error.errors.length > 0) {
    const firstError = error.errors[0];
    return new GoogleAdsError(
      firstError.message,
      firstError.error_code,
      firstError,
    );
  }

  return new GoogleAdsError("An unknown error occurred", "UNKNOWN", error);
}