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

export async function POST(request: NextRequest) {
  try {
    // Ambil form data dari request
    const formData = await request.formData();
    const file = formData.get('file') as File;
    
    if (!file) {
      return NextResponse.json({ message: 'No file uploaded' }, { status: 400 });
    }
    
    // Baca konten file sebagai array buffer
    const fileBuffer = await file.arrayBuffer();
    
    // Proses data file berdasarkan tipe file
    let validData = [];
    let errors: string[] = [];
    
    if (file.name.endsWith('.csv') || file.type === 'text/csv') {
      // Proses sebagai CSV
      const fileContent = await file.text();
      const result = await processCSVData(fileContent);
      validData = result.validData;
      errors = result.errors;
    } else {
      // Proses sebagai Excel
      const result = await processExcelData(fileBuffer);
      validData = result.validData;
      errors = result.errors;
    }
    
    if (validData.length === 0) {
      return NextResponse.json({ 
        message: 'Tidak ada data valid yang ditemukan dalam file', 
        errors 
      }, { status: 400 });
    }
    
    // Insert data valid ke database
    const { insertedCount, errorCount } = await insertDataToDatabase(validData);
    
    return NextResponse.json({ 
      message: 'File processed successfully',
      insertedCount,
      errorCount,
      errors: errors.length > 0 ? errors : undefined
    });
    
  } catch (error) {
    console.error('Error processing file upload:', error);
    return NextResponse.json({ 
      message: 'Error processing file upload',
      error: (error as Error).message 
    }, { status: 500 });
  }
}

// Fungsi untuk memproses data Excel
async function processExcelData(fileBuffer: ArrayBuffer) {
  try {
    // Parse Excel file
    const workbook = XLSX.read(fileBuffer, { type: 'array' });
    
    // Get first sheet
    const sheetName = workbook.SheetNames[0];
    const worksheet = workbook.Sheets[sheetName];
    
    // Convert to JSON with proper typing
    const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 }) as any[][];
    
    if (jsonData.length === 0) {
      return { validData: [], errors: ['Excel file is empty'] };
    }
    
    // Convert Excel data to CSV-like format for processing
    const headers = jsonData[0].map(h => String(h).toLowerCase());
    const rows = jsonData.slice(1);
    
    // Process the data using the common function
    return processData(headers, rows);
  } catch (error) {
    console.error('Error processing Excel data:', error);
    return { validData: [], errors: [(error as Error).message] };
  }
}

// Fungsi untuk memproses data CSV
async function processCSVData(fileContent: string) {
  const lines = fileContent.split(/\r?\n/).filter(line => line.trim() !== '');
  
  if (lines.length === 0) {
    return { validData: [], errors: ['CSV file is empty'] };
  }
  
  // Get headers from first line
  const headerLine = lines[0].toLowerCase();
  const headers = headerLine.split(',').map(h => h.trim());
  
  // Process data rows
  const rows = lines.slice(1).map(line => line.split(',').map(v => v.trim()));
  
  return processData(headers, rows);
}

// Common function to process data regardless of source format
function processData(headers: string[], rows: any[][]) {
  // Define expected headers and their possible variations
  const expectedHeaderMap = {
    nim: ['nim'],
    nama: ['nama', 'name'],
    jenis_kelamin: ['jenis_kelamin', 'jk', 'gender'],
    agama: ['agama', 'religion'],
    kabupaten: ['kabupaten', 'kota', 'city'],
    provinsi: ['provinsi', 'province'],
    jenis_pendaftaran: ['jenis_pendaftaran', 'jalur_masuk', 'admission_type'],
    tahun_angkatan: ['tahun_angkatan', 'angkatan', 'tahun', 'year'],
    ipk: ['ipk', 'gpa'],
    kelompok_keahlian: ['kelompok_keahlian', 'kk', 'keahlian', 'id_kk'],
    status_kuliah: ['status_kuliah', 'status', 'status_mahasiswa'],
    semester: ['semester', 'sem'],
    pembimbing_1_nip: ['pembimbing_1_nip', 'nip_pembimbing_1', 'pembimbing1_nip', 'dosen_pembimbing_1'],
    pembimbing_2_nip: ['pembimbing_2_nip', 'nip_pembimbing_2', 'pembimbing2_nip', 'dosen_pembimbing_2'],
    status_bimbingan: ['status_bimbingan', 'status_guidance', 'bimbingan_status']
  };
  
  // Map actual headers to expected headers
  const headerMap: { [key: string]: number } = {};
  for (const [expectedHeader, variations] of Object.entries(expectedHeaderMap)) {
    const index = headers.findIndex(h => variations.includes(h));
    if (index !== -1) {
      headerMap[expectedHeader] = index;
    }
  }
  
  // Check required headers
  const requiredHeaders = ['nim', 'nama', 'jenis_kelamin', 'tahun_angkatan'];
  const missingHeaders = requiredHeaders.filter(h => headerMap[h] === undefined);
  
  if (missingHeaders.length > 0) {
    return { 
      validData: [], 
      errors: [`Missing required headers: ${missingHeaders.join(', ')}`] 
    };
  }
  
  const validData = [];
  const errors = [];
  
  // Process data rows
  for (let i = 0; i < rows.length; i++) {
    const values = rows[i];
    if (!values || values.length === 0) continue;
    
    try {
      // Extract values using header map
      const nim = String(values[headerMap.nim] || '');
      const nama = String(values[headerMap.nama] || '');
      const jenis_kelamin = mapGender(String(values[headerMap.jenis_kelamin] || ''));
      const tahun_angkatan = String(values[headerMap.tahun_angkatan] || '');
      
      // Optional fields
      const agama = headerMap.agama !== undefined ? String(values[headerMap.agama] || '') || null : null;
      const kabupaten = headerMap.kabupaten !== undefined ? String(values[headerMap.kabupaten] || '') || null : null;
      const provinsi = headerMap.provinsi !== undefined ? String(values[headerMap.provinsi] || '') || null : null;
      const jenis_pendaftaran = headerMap.jenis_pendaftaran !== undefined ? String(values[headerMap.jenis_pendaftaran] || '') || null : null;
      
      // Handle IPK (could be number or string)
      let ipk = null;
      if (headerMap.ipk !== undefined && values[headerMap.ipk] !== undefined && values[headerMap.ipk] !== null) {
        const ipkValue = values[headerMap.ipk];
        const ipkStr = typeof ipkValue === 'number' ? ipkValue.toString() : String(ipkValue);
        ipk = ipkStr ? parseFloat(ipkStr) : null;
      }
      
      // Handle kelompok_keahlian (could be number or string)
      let kelompok_keahlian_id = null;
      if (headerMap.kelompok_keahlian !== undefined && values[headerMap.kelompok_keahlian] !== undefined) {
        const kkValue = values[headerMap.kelompok_keahlian];
        if (kkValue !== null && kkValue !== '') {
          kelompok_keahlian_id = typeof kkValue === 'number' ? kkValue : parseInt(String(kkValue));
        }
      }
      
      // Handle status_kuliah
      let status_kuliah = 'Aktif'; // Default value
      if (headerMap.status_kuliah !== undefined && values[headerMap.status_kuliah] !== undefined) {
        const statusValue = String(values[headerMap.status_kuliah] || '').trim();
        if (statusValue) {
          const mappedStatus = mapStatus(statusValue);
          if (mappedStatus) {
            status_kuliah = mappedStatus;
          }
        }
      }
      
      // Handle semester (could be number or string)
      let semester = 1; // Default value
      if (headerMap.semester !== undefined && values[headerMap.semester] !== undefined) {
        const semesterValue = values[headerMap.semester];
        if (semesterValue !== null && semesterValue !== '') {
          const semesterNum = typeof semesterValue === 'number' ? semesterValue : parseInt(String(semesterValue));
          if (!isNaN(semesterNum) && semesterNum >= 1 && semesterNum <= 14) {
            semester = semesterNum;
          }
        }
      }
      
      // Handle pembimbing NIP
      const pembimbing_1_nip = headerMap.pembimbing_1_nip !== undefined ? String(values[headerMap.pembimbing_1_nip] || '') || null : null;
      const pembimbing_2_nip = headerMap.pembimbing_2_nip !== undefined ? String(values[headerMap.pembimbing_2_nip] || '') || null : null;
      
      // Handle status bimbingan
      let status_bimbingan = 'Belum Selesai'; // Default value
      if (headerMap.status_bimbingan !== undefined && values[headerMap.status_bimbingan] !== undefined) {
        const statusValue = String(values[headerMap.status_bimbingan] || '').trim();
        if (statusValue) {
          const mappedStatus = mapStatusBimbingan(statusValue);
          if (mappedStatus) {
            status_bimbingan = mappedStatus;
          }
        }
      }
      
      // Validate required fields
      if (!nim || !nama || !jenis_kelamin || !tahun_angkatan) {
        errors.push(`Row ${i+1}: Missing required fields`);
        continue;
      }
      
      // Validate NIM format (should be alphanumeric and proper length)
      if (!/^[A-Za-z0-9]{8,12}$/.test(nim)) {
        errors.push(`Row ${i+1}: Invalid NIM format - ${nim}`);
        continue;
      }
      
      // Validate tahun_angkatan format (should be 4 digits)
      if (!/^\d{4}$/.test(tahun_angkatan)) {
        errors.push(`Row ${i+1}: Invalid tahun_angkatan format - ${tahun_angkatan}`);
        continue;
      }
      
      // Validate IPK if provided
      if (ipk !== null && (isNaN(ipk) || ipk < 0 || ipk > 4)) {
        errors.push(`Row ${i+1}: Invalid IPK value - ${ipk}`);
        continue;
      }
      
      // Validate semester if provided
      if (semester < 1 || semester > 14) {
        errors.push(`Row ${i+1}: Invalid semester value - ${semester} (must be between 1-14)`);
        continue;
      }
      
      // Add to valid data
      validData.push({
        nim,
        nama,
        jk: jenis_kelamin,
        agama,
        kabupaten,  
        provinsi,
        jenis_pendaftaran,
        tahun_angkatan,
        ipk,
        kelompok_keahlian_id,
        status_kuliah,
        semester,
        pembimbing_1_nip,
        pembimbing_2_nip,
        status_bimbingan
      });
      
    } catch (error) {
      errors.push(`Row ${i+1}: Error processing row - ${(error as Error).message}`);
    }
  }
  
  return { validData, errors };
}

// Function to map gender values to standardized format
function mapGender(value: string): 'Pria' | 'Wanita' | null {
  if (!value) return null;
  
  const lowerValue = value.toLowerCase();
  
  if (['pria', 'laki-laki', 'laki', 'l', 'male', 'm', 'p'].includes(lowerValue)) {
    return 'Pria';
  }
  
  if (['wanita', 'perempuan', 'w', 'female', 'f', 'woman', 'w'].includes(lowerValue)) {
    return 'Wanita';
  }
  
  return null;
}

// Function to map status values to standardized format
function mapStatus(value: string): 'Aktif' | 'Cuti' | 'Lulus' | 'Non-Aktif' | null {
  if (!value) return null;
  
  const lowerValue = value.toLowerCase();
  
  if (['aktif', 'active', 'a'].includes(lowerValue)) {
    return 'Aktif';
  }
  
  if (['cuti', 'leave', 'c'].includes(lowerValue)) {
    return 'Cuti';
  }
  
  if (['lulus', 'graduated', 'graduate', 'l'].includes(lowerValue)) {
    return 'Lulus';
  }
  
  if (['non-aktif', 'non aktif', 'nonaktif', 'non-aktif', 'non aktif', 'nonaktif', 'n'].includes(lowerValue)) {
    return 'Non-Aktif';
  }
  
  return null;
}

// Function to map status bimbingan values to standardized format
function mapStatusBimbingan(value: string): 'Selesai' | 'Belum Selesai' | null {
  if (!value) return null;
  
  const lowerValue = value.toLowerCase();
  
  if (['selesai', 'completed', 'done', 'finished', 's', '1'].includes(lowerValue)) {
    return 'Selesai';
  }
  
  if (['belum selesai', 'belum_selesai', 'not completed', 'incomplete', 'ongoing', 'in progress', 'b', '0'].includes(lowerValue)) {
    return 'Belum Selesai';
  }
  
  return null;
}

// Fungsi untuk insert data ke database
async function insertDataToDatabase(data: any[]) {
  let insertedCount = 0;
  let errorCount = 0;
  
  for (const item of data) {
    try {
      // Cek apakah mahasiswa sudah ada
      const { data: existingData } = await supabase
        .from('mahasiswa')
        .select('nim')
        .eq('nim', item.nim)
        .single();
      
      // Lookup pembimbing berdasarkan NIP
      let pembimbing_1_id = null;
      let pembimbing_2_id = null;
      
      if (item.pembimbing_1_nip) {
        const { data: dosen1 } = await supabase
          .from('dosen')
          .select('id_dosen')
          .eq('nip', item.pembimbing_1_nip)
          .single();
        pembimbing_1_id = dosen1?.id_dosen || null;
      }
      
      if (item.pembimbing_2_nip) {
        const { data: dosen2 } = await supabase
          .from('dosen')
          .select('id_dosen')
          .eq('nip', item.pembimbing_2_nip)
          .single();
        pembimbing_2_id = dosen2?.id_dosen || null;
      }
      
      const mahasiswaData = {
        nama: item.nama,
        jk: item.jk,
        agama: item.agama,
        kabupaten: item.kabupaten,
        provinsi: item.provinsi,
        jenis_pendaftaran: item.jenis_pendaftaran,
        tahun_angkatan: item.tahun_angkatan,
        ipk: item.ipk,
        id_kelompok_keahlian: item.kelompok_keahlian_id,
        status_kuliah: item.status_kuliah,
        semester: item.semester,
        pembimbing_1: pembimbing_1_id,
        pembimbing_2: pembimbing_2_id,
        status_bimbingan: item.status_bimbingan
      };
      
      if (existingData) {
        // Update record yang sudah ada
        const { error } = await supabase
          .from('mahasiswa')
          .update(mahasiswaData)
          .eq('nim', item.nim);
          
        if (error) throw error;
      } else {
        // Insert record baru
        const { error } = await supabase
          .from('mahasiswa')
          .insert({
            nim: item.nim,
            ...mahasiswaData
          });
          
        if (error) throw error;
      }
      
      insertedCount++;
    } catch (error) {
      console.error(`Error inserting/updating record for NIM ${item.nim}:`, error);
      errorCount++;
    }
  }
  
  return { insertedCount, errorCount };
}