portaldata/app/api/keloladata/data-beasiswa-mahasiswa/route.ts

import { NextRequest, NextResponse } from 'next/server';
import supabase from '@/lib/db';

// GET - Fetch all beasiswa mahasiswa or filter by criteria
export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const id = searchParams.get('id');
    const id_mahasiswa = searchParams.get('id_mahasiswa');
    const search = searchParams.get('search');
    const jenisBeasiswa = searchParams.get('jenis_beasiswa');

    // If ID is provided, fetch specific beasiswa by ID with join
    if (id) {
      const { data, error } = await supabase
        .from('beasiswa_mahasiswa')
        .select(`
          *,
          mahasiswa!inner(nama, nim)
        `)
        .eq('id_beasiswa', id)
        .single();

      if (error || !data) {
        return NextResponse.json({ message: 'Beasiswa mahasiswa not found' }, { status: 404 });
      }

      // Transform the data to flatten the nama and nim fields
      const transformedData = {
        ...data,
        nama: data.mahasiswa.nama,
        nim: data.mahasiswa.nim
      };
      delete transformedData.mahasiswa;

      return NextResponse.json(transformedData);
    }

    // If id_mahasiswa is provided, fetch beasiswa for specific student with join
    if (id_mahasiswa) {
      const { data, error } = await supabase
        .from('beasiswa_mahasiswa')
        .select(`
          *,
          mahasiswa!inner(nama, nim)
        `)
        .eq('id_mahasiswa', id_mahasiswa)
        .order('created_at', { ascending: false });

      if (error) {
        console.error('Error fetching data:', error);
        return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
      }

      // Transform the data to flatten the nama and nim fields
      const transformedData = data.map(item => ({
        ...item,
        nama: item.mahasiswa.nama,
        nim: item.mahasiswa.nim
      })).map(({ mahasiswa, ...rest }) => rest);

      return NextResponse.json(transformedData);
    }

    // Build the query based on filters with join
    let query = supabase.from('beasiswa_mahasiswa').select(`
      *,
      mahasiswa!inner(nama, nim)
    `);

    // Add search condition if provided
    if (search) {
      query = query.or(`mahasiswa.nama.ilike.%${search}%,mahasiswa.nim.ilike.%${search}%,nama_beasiswa.ilike.%${search}%,sumber_beasiswa.ilike.%${search}%`);
    }

    // Add jenis_beasiswa filter if provided
    if (jenisBeasiswa) {
      query = query.eq('jenis_beasiswa', jenisBeasiswa);
    }

    // Add order by
    query = query.order('created_at', { ascending: false });

    // Execute the query
    const { data, error } = await query;

    if (error) {
      console.error('Error fetching data:', error);
      return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
    }

    // Transform the data to flatten the nama and nim fields
    const transformedData = data.map(item => ({
      ...item,
      nama: item.mahasiswa.nama,
      nim: item.mahasiswa.nim
    })).map(({ mahasiswa, ...rest }) => rest);

    return NextResponse.json(transformedData);
  } catch (error) {
    console.error('Error fetching data:', error);
    return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
  }
}

// POST - Create a new beasiswa mahasiswa
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const {
      nim,
      nama_beasiswa,
      sumber_beasiswa,
      beasiswa_status,
      jenis_beasiswa
    } = body;

    // Validate required fields
    if (!nim || !nama_beasiswa || !sumber_beasiswa || !beasiswa_status || !jenis_beasiswa) {
      return NextResponse.json(
        { message: 'Missing required fields: nim, nama_beasiswa, sumber_beasiswa, beasiswa_status, jenis_beasiswa' },
        { status: 400 }
      );
    }

    // Check if mahasiswa exists by NIM and get id_mahasiswa
    const { data: mahasiswaExists, error: checkError } = await supabase
      .from('mahasiswa')
      .select('id_mahasiswa, nama')
      .eq('nim', nim)
      .single();

    if (checkError || !mahasiswaExists) {
      return NextResponse.json(
        { message: `Mahasiswa dengan NIM ${nim} tidak terdaftar dalam database` },
        { status: 404 }
      );
    }

    // Validate enum values
    const validStatus = ['Aktif', 'Selesai', 'Dibatalkan'];
    const validJenisBeasiswa = ['Pemerintah', 'Non-Pemerintah'];

    if (!validStatus.includes(beasiswa_status)) {
      return NextResponse.json(
        { message: 'Invalid beasiswa_status value. Must be one of: Aktif, Selesai, Dibatalkan' },
        { status: 400 }
      );
    }

    if (!validJenisBeasiswa.includes(jenis_beasiswa)) {
      return NextResponse.json(
        { message: 'Invalid jenis_beasiswa value. Must be one of: Pemerintah, Non-Pemerintah' },
        { status: 400 }
      );
    }

    // Insert new beasiswa using id_mahasiswa
    const { data, error } = await supabase
      .from('beasiswa_mahasiswa')
      .insert({
        id_mahasiswa: mahasiswaExists.id_mahasiswa,
        nama_beasiswa,
        sumber_beasiswa,
        beasiswa_status,
        jenis_beasiswa
      })
      .select()
      .single();

    if (error) {
      console.error('Error creating beasiswa mahasiswa:', error);
      return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
    }

    return NextResponse.json(
      { 
        message: `Beasiswa berhasil ditambahkan`, 
        id: data.id_beasiswa 
      },
      { status: 201 }
    );
  } catch (error) {
    console.error('Error creating beasiswa mahasiswa:', error);
    return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
  }
}

// PUT - Update an existing beasiswa mahasiswa
export async function PUT(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const id = searchParams.get('id');

    if (!id) {
      return NextResponse.json({ message: 'ID is required' }, { status: 400 });
    }

    const body = await request.json();
    const {
      nim,
      nama_beasiswa,
      sumber_beasiswa,
      beasiswa_status,
      jenis_beasiswa
    } = body;

    // Validate required fields
    if (!nim || !nama_beasiswa || !sumber_beasiswa || !beasiswa_status || !jenis_beasiswa) {
      return NextResponse.json(
        { message: 'Missing required fields: nim, nama_beasiswa, sumber_beasiswa, beasiswa_status, jenis_beasiswa' },
        { status: 400 }
      );
    }

    // Check if beasiswa exists
    const { data: existing, error: checkError } = await supabase
      .from('beasiswa_mahasiswa')
      .select('*')
      .eq('id_beasiswa', id)
      .single();

    if (checkError || !existing) {
      return NextResponse.json({ message: 'Beasiswa mahasiswa not found' }, { status: 404 });
    }

    // Check if mahasiswa exists by NIM and get id_mahasiswa
    const { data: mahasiswaExists, error: mahasiswaCheckError } = await supabase
      .from('mahasiswa')
      .select('id_mahasiswa, nama')
      .eq('nim', nim)
      .single();

    if (mahasiswaCheckError || !mahasiswaExists) {
      return NextResponse.json(
        { message: `Mahasiswa dengan NIM ${nim} tidak terdaftar` },
        { status: 404 }
      );
    }

    // Validate enum values
    const validStatus = ['Aktif', 'Selesai', 'Dibatalkan'];
    const validJenisBeasiswa = ['Pemerintah', 'Non-Pemerintah'];

    if (!validStatus.includes(beasiswa_status)) {
      return NextResponse.json(
        { message: 'Invalid beasiswa_status value. Must be one of: Aktif, Selesai, Dibatalkan' },
        { status: 400 }
      );
    }

    if (!validJenisBeasiswa.includes(jenis_beasiswa)) {
      return NextResponse.json(
        { message: 'Invalid jenis_beasiswa value. Must be one of: Pemerintah, Non-Pemerintah' },
        { status: 400 }
      );
    }

    // Update beasiswa using id_mahasiswa
    const { error } = await supabase
      .from('beasiswa_mahasiswa')
      .update({
        id_mahasiswa: mahasiswaExists.id_mahasiswa,
        nama_beasiswa,
        sumber_beasiswa,
        beasiswa_status,
        jenis_beasiswa
      })
      .eq('id_beasiswa', id);

    if (error) {
      console.error('Error updating beasiswa mahasiswa:', error);
      return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
    }

    return NextResponse.json({ 
      message: `Beasiswa berhasil diperbarui` 
    });
  } catch (error) {
    console.error('Error updating beasiswa mahasiswa:', error);
    return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
  }
}

// DELETE - Delete a beasiswa mahasiswa
export async function DELETE(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const id = searchParams.get('id');

    if (!id) {
      return NextResponse.json({ message: 'ID is required' }, { status: 400 });
    }

    // Check if beasiswa exists
    const { data: existing, error: checkError } = await supabase
      .from('beasiswa_mahasiswa')
      .select('id_beasiswa')
      .eq('id_beasiswa', id)
      .single();

    if (checkError || !existing) {
      return NextResponse.json({ message: 'Beasiswa mahasiswa not found' }, { status: 404 });
    }

    // Delete beasiswa
    const { error } = await supabase
      .from('beasiswa_mahasiswa')
      .delete()
      .eq('id_beasiswa', id);

    if (error) {
      console.error('Error deleting beasiswa mahasiswa:', error);
      return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
    }

    return NextResponse.json({ message: 'Beasiswa mahasiswa deleted successfully' });
  } catch (error) {
    console.error('Error deleting beasiswa mahasiswa:', error);
    return NextResponse.json({ message: 'Internal Server Error' }, { status: 500 });
  }
}