import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
import type { Tables } from '@kit/supabase/database';
import { getSupabaseServerClient } from '@kit/supabase/server-client';
import type { StoreOrder } from '@medusajs/types';

export type AnalysisOrder = Tables<{ schema: 'medreport' }, 'analysis_orders'>;

export async function createOrder({
  medusaOrder,
  orderedAnalysisElements,
}: {
  medusaOrder: StoreOrder;
  orderedAnalysisElements: { analysisElementId?: number; analysisId?: number }[];
}) {
  const supabase = getSupabaseServerClient();

  const { data: { user } } = await supabase.auth.getUser();
  if (!user) {
    throw new Error('User not found');
  }
  const orderResult = await supabase.schema('medreport')
    .from('analysis_orders')
    .insert({
      analysis_element_ids: orderedAnalysisElements.map(({ analysisElementId }) => analysisElementId).filter(Boolean) as number[],
      analysis_ids: orderedAnalysisElements.map(({ analysisId }) => analysisId).filter(Boolean) as number[],
      status: 'QUEUED',
      user_id: user.id,
      medusa_order_id: medusaOrder.id,
    })
    .select('id')
    .single()
    .throwOnError();

  if (orderResult.error || !orderResult.data?.id) {
    throw new Error(`Failed to create order, message=${orderResult.error}, data=${JSON.stringify(orderResult)}`);
  }

  return orderResult.data.id;
}

export async function updateOrder({
  orderId,
  orderStatus,
}: {
  orderId: number;
  orderStatus: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status'];
}) {
  console.info(`Updating order id=${orderId} status=${orderStatus}`);
  await getSupabaseServerAdminClient()
    .schema('medreport')
    .from('analysis_orders')
    .update({
      status: orderStatus,
    })
    .eq('id', orderId)
    .throwOnError();
}

export async function updateOrderStatus({
  orderId,
  medusaOrderId,
  orderStatus,
}: {
  orderId?: number;
  medusaOrderId?: string;
  orderStatus: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status'];
}) {
  const orderIdParam = orderId;
  const medusaOrderIdParam = medusaOrderId;
  if (!orderIdParam && !medusaOrderIdParam) {
    throw new Error('Either orderId or medusaOrderId must be provided');
  }
  await getSupabaseServerAdminClient()
    .schema('medreport')
    .rpc('update_analysis_order_status', {
      order_id: orderIdParam ?? -1,
      status_param: orderStatus,
      medusa_order_id_param: medusaOrderIdParam ?? '',
    })
    .throwOnError();
}

export async function getOrder({
  medusaOrderId,
  orderId,
}: {
  medusaOrderId?: string;
  orderId?: number;
}) {
  const query = getSupabaseServerAdminClient()
    .schema('medreport')
    .from('analysis_orders')
    .select('*')
  if (medusaOrderId) {
    query.eq('medusa_order_id', medusaOrderId);
  } else if (orderId) {
    query.eq('id', orderId);
  } else {
    throw new Error('Either medusaOrderId or orderId must be provided');
  }

  const { data: order, error } = await query.single();
  if (error) {
    throw new Error(`Failed to get order by medusaOrderId=${medusaOrderId} or orderId=${orderId}, message=${error.message}, data=${JSON.stringify(order)}`);
  }
  return order;
}

export async function getAnalysisOrders({
  orderStatus,
}: {
  orderStatus?: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status'];
} = {}) {
  const client = getSupabaseServerClient();
  
  const {
    data: { user },
  } = await client.auth.getUser();
  if (!user) {
    throw new Error('Unauthorized');
  }

  const query = client
    .schema('medreport')
    .from('analysis_orders')
    .select('*')
    .eq("user_id", user.id)
  if (orderStatus) {
    query.eq('status', orderStatus);
  }
  const orders = await query.order('created_at', { ascending: false }).throwOnError();
  return orders.data;
}

export async function getAnalysisOrdersAdmin({
  orderStatus,
  medusaOrderId,
}: {
  orderStatus?: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status'];
  medusaOrderId?: string | null;
} = {}) {
  const query = getSupabaseServerAdminClient()
    .schema('medreport')
    .from('analysis_orders')
    .select('*')
  if (orderStatus) {
    query.eq('status', orderStatus);
  }
  if (medusaOrderId) {
    query.eq('medusa_order_id', medusaOrderId);
  }
  const orders = await query.order('created_at', { ascending: false }).throwOnError();
  return orders.data;
}