import type { VercelRequest, VercelResponse } from '@vercel/node';
import { createClient } from '@supabase/supabase-js';
import { Experiment, ExperimentCreateInput } from '../types';

const supabase = createClient(
  process.env.SUPABASE_URL || '',
  process.env.SUPABASE_SERVICE_KEY || '',
  {
    auth: {
      autoRefreshToken: false,
      persistSession: false
    }
  }
);

export default async function handler(req: VercelRequest, res: VercelResponse) {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');

  if (req.method === 'OPTIONS') return res.status(200).end();

  try {
    // GET - List experiments or get single experiment
    if (req.method === 'GET') {
      const { id, status, type, marketplace, asin, dateFrom, dateTo } = req.query;

      let query = supabase.from('experiments').select('*');

      if (id) {
        const { data, error } = await query.eq('id', id).single();
        if (error) throw error;
        return res.status(200).json(data);
      }

      // List with filters
      if (status) {
        const statuses = Array.isArray(status) ? status : [status];
        query = query.in('status', statuses);
      }
      if (type) {
        const types = Array.isArray(type) ? type : [type];
        query = query.in('type', types);
      }
      if (marketplace) {
        const markets = Array.isArray(marketplace) ? marketplace : [marketplace];
        query = query.in('marketplace', markets);
      }
      if (asin) {
        query = query.contains('asins', [asin]);
      }
      if (dateFrom) {
        query = query.gte('start_date', dateFrom as string);
      }
      if (dateTo) {
        query = query.lte('end_date', dateTo as string);
      }

      const { data, error } = await query.order('created_at', { ascending: false });
      if (error) throw error;

      return res.status(200).json(data || []);
    }

    // POST - Create experiment
    if (req.method === 'POST') {
      const input: ExperimentCreateInput = req.body;

      const { data, error } = await supabase
        .from('experiments')
        .insert([{
          ...input,
          status: 'planned',
          created_at: new Date().toISOString(),
          updated_at: new Date().toISOString(),
        }])
        .select()
        .single();

      if (error) throw error;
      return res.status(201).json(data);
    }

    // PUT - Update experiment
    if (req.method === 'PUT') {
      const { id } = req.query;
      const updates = req.body;

      const { data, error } = await supabase
        .from('experiments')
        .update({ ...updates, updated_at: new Date().toISOString() })
        .eq('id', id)
        .select()
        .single();

      if (error) throw error;
      return res.status(200).json(data);
    }

    // DELETE - Delete experiment
    if (req.method === 'DELETE') {
      const { id } = req.query;

      const { error } = await supabase
        .from('experiments')
        .delete()
        .eq('id', id);

      if (error) throw error;
      return res.status(200).json({ success: true });
    }

    return res.status(405).json({ error: 'Method not allowed' });
  } catch (error: any) {
    console.error('Experiments API error:', error);
    return res.status(500).json({ error: error.message || 'Internal server error' });
  }
}