Labour & Payroll Logic

class PayrollService {

  /** Process daily attendance — validate shift and compute hours */
  async processAttendance(projectId, date) {
    const records = await Attendance.findAll({
      project_id: projectId, attendance_date: date
    });
    for (const rec of records) {
      const shift = await Shift.findById(rec.shift_id);
      const shiftHours = (shift.end_time - shift.start_time) / 3600000;
      const worked = (rec.check_out - rec.check_in) / 3600000;
      await rec.update({
        hours_worked: Math.min(worked, shiftHours),
        ot_hours: Math.max(0, worked - shiftHours)
      });
    }
  }

  /** Calculate overtime amount for a worker in a given month */
  async calculateOT(workerId, month) {
    const worker = await Worker.findById(workerId);
    const attendance = await Attendance.findAll({
      worker_id: workerId, period: month, ot_hours: { gt: 0 }
    });
    const shift = await Shift.findById(attendance[0].shift_id);
    const shiftHrs = (shift.end_time - shift.start_time) / 3600000;
    const hourlyRate = worker.daily_wage / shiftHrs;
    const totalOTHours = attendance.reduce((s, a) => s + a.ot_hours, 0);
    return totalOTHours * hourlyRate * shift.ot_multiplier;
  }

  /** Run monthly payroll for a project — creates payroll_run + details */
  async runPayroll(projectId, month, year) {
    const workers = await Worker.findAll({ project_id: projectId, status: 'active' });
    const run = await PayrollRun.create({
      project_id: projectId, period_month: `${year}-${month}`, status: 'draft'
    });
    let totalGross = 0, totalDeductions = 0, totalNet = 0;

    for (const w of workers) {
      const daysWorked = await Attendance.count({
        worker_id: w.worker_id, period: month
      });
      const basicPay = daysWorked * w.daily_wage;
      const otAmount = await this.calculateOT(w.worker_id, month);
      const grossPay = basicPay + otAmount;
      const deductions = await this.calculateStatutoryDeductions(grossPay, w);
      const netPay = grossPay - deductions.total;

      await PayrollDetail.create({
        payroll_id: run.payroll_id, worker_id: w.worker_id,
        days_worked: daysWorked, basic_pay: basicPay,
        ot_amount: otAmount, gross_pay: grossPay,
        pf_employee: deductions.pf, esi_employee: deductions.esi,
        tds: deductions.tds, net_pay: netPay
      });
      totalGross += grossPay; totalDeductions += deductions.total; totalNet += netPay;
    }
    await run.update({ total_gross: totalGross, total_deductions: totalDeductions, total_net: totalNet });
    return run;
  }

  /** Calculate PF, ESI, PT, TDS deductions based on worker profile */
  async calculateStatutoryDeductions(grossPay, workerProfile) {
    const structure = await WageStructure.findById(workerProfile.structure_id);
    const basicComponent = grossPay * (structure.basic_percent / 100);
    const pfBasic = Math.min(basicComponent, 15000); // PF ceiling ₹15,000
    const pf = pfBasic * 0.12;                        // Employee PF 12%
    const esi = grossPay <= 21000 ? grossPay * 0.0075 : 0; // ESI if gross ≤ ₹21,000
    const pt = await ProfessionalTax.calculate(workerProfile.state, grossPay);
    const tds = await TDSCalculator.compute(grossPay * 12, workerProfile);
    return { pf, esi, pt, tds, total: pf + esi + pt + tds };
  }

  /** Generate NEFT/RTGS bank file for bulk salary disbursement */
  async generateBankFile(payrollId) {
    const details = await PayrollDetail.findAll({ payroll_id: payrollId });
    const rows = [];
    for (const d of details) {
      const worker = await Worker.findById(d.worker_id);
      rows.push({ ifsc: worker.bank_ifsc, account: worker.bank_account,
        name: worker.name, amount: d.net_pay });
    }
    return BankFileGenerator.createNEFT(rows);
  }

  /** Post payroll journal entry to GL */
  async postToGL(payrollId) {
    const run = await PayrollRun.findById(payrollId);
    const je = await JournalEntry.create({
      je_type: 'PAYROLL', source_module: 'payroll',
      total_debit: run.total_gross, total_credit: run.total_gross
    });
    // Dr: Labour Expense (by cost centre)
    await JournalLine.create({ je_id: je.je_id, account: 'LABOUR_EXPENSE', debit: run.total_gross });
    // Cr: Bank, PF Payable, ESI Payable, TDS Payable
    await JournalLine.create({ je_id: je.je_id, account: 'BANK', credit: run.total_net });
    await JournalLine.create({ je_id: je.je_id, account: 'PF_PAYABLE', credit: run.total_pf });
    await JournalLine.create({ je_id: je.je_id, account: 'ESI_PAYABLE', credit: run.total_esi });
    await JournalLine.create({ je_id: je.je_id, account: 'TDS_PAYABLE', credit: run.total_tds });
    return je;
  }

  /** Generate muster roll for statutory compliance */
  async generateMusterRoll(projectId, month) {
    const details = await PayrollDetail.findAll({ project_id: projectId, period: month });
    const totalWorkers = details.length;
    const totalWages = details.reduce((s, d) => s + d.gross_pay, 0);
    const pfContrib = details.reduce((s, d) => s + d.pf_employee, 0) * 2; // Employee + Employer
    return await MusterRoll.create({
      period_month: month, total_workers: totalWorkers,
      total_wages: totalWages, pf_contribution: pfContrib
    });
  }
}