/**
 * Affiliate Service — proxies to the EventheOdds PHP affiliate API
 */

const AFFILIATE_API_URL = process.env.AFFILIATE_API_URL || 'https://eventheodds.ai/php-api/affiliate.php';
const SITE_ID = 'rainmaker';

interface TrackClickResult {
  success: boolean;
  tracking_id?: string;
  visitor_id?: string;
  error?: string;
}

interface TrackConversionResult {
  success: boolean;
  conversion_id?: string;
  error?: string;
}

export async function trackAffiliateClick(affiliateCode: string, referrer?: string): Promise<TrackClickResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'track_click');
    url.searchParams.set('site_id', SITE_ID);
    const resp = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        affiliate_code: affiliateCode,
        referrer: referrer || '',
      }),
    });
    const data = await resp.json() as TrackClickResult;
    return data;
  } catch (err) {
    console.error('Affiliate trackClick error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}

interface AffiliateOffer {
  id: string;
  title: string;
  description: string;
  payout: number;
  type: string;
}

interface GetOffersResult {
  success: boolean;
  offers?: AffiliateOffer[];
  error?: string;
}

interface RegisterAffiliateResult {
  success: boolean;
  affiliate_code?: string;
  unique_id?: string;
  error?: string;
}

export async function getOffers(): Promise<GetOffersResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'get_offers');
    url.searchParams.set('site_id', SITE_ID);
    const resp = await fetch(url);
    const data = await resp.json() as GetOffersResult;
    return data;
  } catch (err) {
    console.error('Affiliate getOffers error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}

export async function registerAffiliate(
  email: string,
  companyName: string,
  password: string,
): Promise<RegisterAffiliateResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'register');
    url.searchParams.set('site_id', SITE_ID);
    const resp = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        email,
        company_name: companyName,
        password,
      }),
    });
    const data = await resp.json() as RegisterAffiliateResult;
    return data;
  } catch (err) {
    console.error('Affiliate register error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}

interface LoginAffiliateResult {
  success: boolean;
  affiliate_id?: string;
  affiliate_code?: string;
  email?: string;
  error?: string;
}

interface AffiliateDashboardResult {
  success: boolean;
  stats?: {
    total_clicks: number;
    total_signups: number;
    total_conversions: number;
    total_earnings: number;
  };
  error?: string;
}

export async function loginAffiliate(email: string, password: string): Promise<LoginAffiliateResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'login');
    url.searchParams.set('site_id', SITE_ID);
    const resp = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, password }),
    });
    const data = await resp.json() as any;
    if (!data.success) {
      return { success: false, error: data.error || 'Login failed' };
    }
    // PHP API nests affiliate data under "affiliate" key
    const aff = data.affiliate || {};
    return {
      success: true,
      affiliate_id: String(aff.id || aff.unique_id || ''),
      affiliate_code: aff.affiliate_code || aff.unique_id || '',
      email: aff.email || email,
    };
  } catch (err) {
    console.error('Affiliate login error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}

export async function getAffiliateDashboard(affiliateId: string): Promise<AffiliateDashboardResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'dashboard');
    url.searchParams.set('site_id', SITE_ID);
    url.searchParams.set('affiliate_id', affiliateId);
    const resp = await fetch(url);
    const data = await resp.json() as any;
    if (!data.success) {
      return { success: false, error: data.error || 'Dashboard fetch failed' };
    }
    const s = data.stats || {};
    return {
      success: true,
      stats: {
        total_clicks: s.clicks || 0,
        total_signups: s.signups || 0,
        total_conversions: s.conversions || 0,
        total_earnings: s.earnings || 0,
      },
    };
  } catch (err) {
    console.error('Affiliate dashboard error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}

export async function trackAffiliateConversion(
  trackingId: string,
  conversionType: 'signup' | 'purchase',
  revenue: number = 0,
): Promise<TrackConversionResult> {
  try {
    const url = new URL(AFFILIATE_API_URL);
    url.searchParams.set('action', 'track_conversion');
    url.searchParams.set('site_id', SITE_ID);
    const resp = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        tracking_id: trackingId,
        conversion_type: conversionType,
        revenue,
      }),
    });
    const data = await resp.json() as TrackConversionResult;
    return data;
  } catch (err) {
    console.error('Affiliate trackConversion error:', err);
    return { success: false, error: 'Failed to reach affiliate API' };
  }
}