import 'server-only';

import { env } from '../config/env';
import { ReclaimProofRequest } from '@reclaimprotocol/js-sdk';
import { supabaseClient } from '../config/supabaseClient';
import { sign } from 'jsonwebtoken';

interface GigResponse {
  action_params: Record<string, any>;
  platform: string;
  gig_type: {
    id: string;
    required_params: { keys: string[] };
    display: {
      [key: string]: any;
    };
  };
}

class ReclaimService {
  static instance: ReclaimService;

  static getInstance() {
    if (!ReclaimService.instance) {
      ReclaimService.instance = new ReclaimService();
    }
    return ReclaimService.instance;
  }

  async getReclaimConfig({ gigId, userId }: { gigId: number; userId: number }) {
    const { data: gig, error } = await supabaseClient
      .from('gigbot_gigs')
      .select('action_params,platform,gig_type(id,required_params,display)')
      .eq('id', gigId)
      .single();

    if (error) {
      throw new Error('Gig not found');
    }

    const _gig = gig as unknown as GigResponse;
    const platformConfig = _gig?.gig_type?.display?.[_gig.platform];

    if (!platformConfig) {
      throw new Error(
        `Could not find configuration for platform '${_gig.platform}' for this gig type '${_gig.gig_type.id}'.`,
      );
    }

    if (!platformConfig.reclaim_params_key) {
      throw new Error('Missing reclaim_params_key in platform config.');
    }
    if (!platformConfig.reclaim_params_value) {
      throw new Error('Missing reclaim_params_value in platform config.');
    }
    if (!platformConfig.reclaim_provider_id) {
      throw new Error('Missing reclaim_provider_id in platform config.');
    }

    const actionParams = gig?.action_params as Record<string, any> | null;

    const reclaimKey = platformConfig.reclaim_params_key;
    const actionParamsReclaimKey = platformConfig.reclaim_params_key;
    const actionValue = actionParams
      ? actionParams[actionParamsReclaimKey]
      : '';

    let reclaimValue = platformConfig.reclaim_params_value;

    if (reclaimValue && actionParamsReclaimKey && actionValue) {
      reclaimValue = reclaimValue.replace(
        `<${actionParamsReclaimKey}>`,
        actionValue,
      );
    }

    const reclaimProofRequest = await ReclaimProofRequest.init(
      env.RECLAIM_APPLICATION_ID,
      env.RECLAIM_APPLICATION_SECRET,
      platformConfig.reclaim_provider_id,
    );

    const token = sign(
      {
        gigId,
        userId,
      },
      env.RECLAIM_JWT_SECRET,
      { expiresIn: '1h' },
    );

    reclaimProofRequest.addContext('metadata', token);
    reclaimProofRequest.setParams({
      [reclaimKey]: reclaimValue,
    });
    reclaimProofRequest.setAppCallbackUrl(
      `${env.NEXT_PUBLIC_APP_BASE_URL}api/reclaim/verify-proof`,
    );

    const jsonString = reclaimProofRequest.toJsonString();
    console.log('jsonString', jsonString);
    return jsonString;
  }
}

export const reclaimService = new ReclaimService();