<?php

namespace App\Http\Controllers\Api;

use App\Models\ClassSection;
use App\Models\Configuration;
use App\Models\InventoryCategory;
use App\Models\InventoryItem;
use App\Models\InventoryMovement;
use App\Models\StudentClass;
use App\Models\TeacherClass;
use App\Models\Teacher;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;

class InventoryController extends BaseApiController
{
    protected InventoryItem $item;
    protected InventoryCategory $cat;
    protected InventoryMovement $mov;
    protected Configuration $config;
    protected TeacherClass $teacherClass;
    protected StudentClass $studentClass;
    protected User $user;
    protected ClassSection $classSection;
    protected Teacher $teacher;
    protected string $schoolYear;
    protected string $semester;
    protected array $types = ['classroom', 'book', 'office', 'kitchen'];
    protected array $movementTypes = ['initial', 'in', 'out', 'adjust', 'distribution'];
    protected array $semesters = ['Spring', 'Fall'];

    public function __construct()
    {
        parent::__construct();
        $this->item = model(InventoryItem::class);
        $this->cat = model(InventoryCategory::class);
        $this->mov = model(InventoryMovement::class);
        $this->user = model(User::class);
        $this->config = model(Configuration::class);
        $this->teacherClass = model(TeacherClass::class);
        $this->studentClass = model(StudentClass::class);
        $this->classSection = model(ClassSection::class);
        $this->teacher = model(Teacher::class);
        $this->schoolYear = (string) ($this->config->getConfig('school_year') ?? '');
        $this->semester = (string) ($this->config->getConfig('semester') ?? '');
    }

    /**
     * GET /api/v1/inventory
     * List inventory items filtered by type, school year, and semester
     */
    public function index()
    {
        $type = $this->normalizeType($this->request->getGet('type') ?? 'classroom');
        $schoolYears = $this->getSchoolYearsForType($type);
        $requested = trim((string) ($this->request->getGet('school_year') ?? ''));
        $selectedYear = $requested !== '' ? $requested : $this->schoolYear;
        $selectedSem = trim((string) ($this->request->getGet('semester') ?? ''));

        $builder = $this->item->where('type', $type);
        if (strtolower($selectedYear) !== 'all') {
            $builder->where('school_year', $selectedYear);
        }
        if ($selectedSem !== '') {
            $builder->where('semester', $selectedSem);
        }

        $items = $builder->orderBy('name', 'ASC')->findAll();
        $categories = $this->cat->optionsForType($type);

        // Build UpdatedBy name map
        $userIds = array_values(array_unique(array_map(fn($i) => (int)($i['updated_by'] ?? 0), $items)));
        $userIds = array_values(array_filter($userIds));
        $userNames = $this->userNamesByIds($userIds);

        return $this->success([
            'type' => $type,
            'items' => $items,
            'categories' => $categories,
            'conditionOptions' => [
                'good' => 'Good condition',
                'needs_repair' => 'Needs repair',
                'need_replace' => 'Need replace',
                'cannot_find' => 'Cannot find'
            ],
            'schoolYears' => $schoolYears,
            'selectedYear' => $selectedYear,
            'currentYear' => $this->schoolYear,
            'semester' => $selectedSem,
            'userNames' => $userNames,
        ], 'Inventory items retrieved successfully');
    }

    /**
     * GET /api/v1/inventory/{id}
     * Get a single inventory item
     */
    public function show($id = null)
    {
        $item = $this->item->find($id);
        if (!$item) {
            return $this->error('Item not found.', Response::HTTP_NOT_FOUND);
        }

        $categories = $this->cat->optionsForType($item['type']);

        return $this->success([
            'type' => $item['type'],
            'item' => $item,
            'categories' => $categories,
            'conditionOptions' => [
                'good' => 'Good condition',
                'needs_repair' => 'Needs repair',
                'need_replace' => 'Need replace',
                'cannot_find' => 'Cannot find'
            ],
            'isEdit' => true,
        ], 'Inventory item retrieved successfully');
    }

    /**
     * GET /api/v1/inventory/create
     * Get form data for creating a new item
     */
    public function create()
    {
        $type = $this->normalizeType($this->request->getGet('type') ?? 'classroom');
        $categories = $this->cat->optionsForType($type);

        return $this->success([
            'type' => $type,
            'item' => [],
            'categories' => $categories,
            'conditionOptions' => [
                'good' => 'Good condition',
                'needs_repair' => 'Needs repair',
                'need_replace' => 'Need replace',
                'cannot_find' => 'Cannot find',
            ],
        ], 'Form data retrieved successfully');
    }

    /**
     * POST /api/v1/inventory
     * Create a new inventory item
     */
    public function store()
    {
        $data = $this->payloadData();
        $itemData = $this->filterItemData($data);

        try {
            $itemId = $this->item->insert($itemData, true);
            if ($itemId) {
                $initialQty = (int) ($itemData['quantity'] ?? 0);
                if ($initialQty !== 0) {
                    $this->recordMovement($itemId, $initialQty, 'initial', 'Initial stock');
                } else {
                    $this->recalcQuantity($itemId);
                }
                $item = $this->item->find($itemId);
                return $this->respondCreated($item, 'Item added.');
            }
            return $this->error('Failed to create item', Response::HTTP_INTERNAL_SERVER_ERROR);
        } catch (\Throwable $e) {
            log_message('error', 'Inventory item creation error: ' . $e->getMessage());
            return $this->error('Failed to create item: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * PATCH /api/v1/inventory/{id}
     * Update an inventory item
     */
    public function update($id = null)
    {
        $item = $this->item->find($id);
        if (!$item) {
            return $this->error('Item not found.', Response::HTTP_NOT_FOUND);
        }

        $data = $this->filterItemData($this->payloadData(), $item['type']);
        unset($data['id']);

        try {
            if (!$this->item->update($id, $data)) {
                $errors = $this->item->errors() ?? [];
                return $this->respondValidationError($errors, 'Validation failed');
            }
            $updatedItem = $this->item->find($id);
            return $this->success($updatedItem, 'Item updated.');
        } catch (\Throwable $e) {
            log_message('error', 'Inventory item update error: ' . $e->getMessage());
            return $this->error('Failed to update item: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * DELETE /api/v1/inventory/{id}
     * Delete an inventory item
     */
    public function delete($id = null)
    {
        $item = $this->item->find($id);
        if (!$item) {
            return $this->error('Item not found.', Response::HTTP_NOT_FOUND);
        }

        try {
            $type = $item['type'];
            $this->item->delete($id);
            return $this->success(['type' => $type], 'Item deleted.');
        } catch (\Throwable $e) {
            log_message('error', 'Inventory item deletion error: ' . $e->getMessage());
            return $this->error('Failed to delete item: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * POST /api/v1/inventory/categories
     * Save a category (create or update)
     */
    public function saveCategory()
    {
        $rawType = (string)($this->request->getPost('type') ?? '');
        $type = strtolower(trim($rawType));
        $id = $this->request->getPost('id');
        $name = preg_replace('/\s+/', ' ', trim((string)$this->request->getPost('name')));

        $data = [
            'type' => in_array($type, ['classroom', 'book', 'office', 'kitchen'], true) ? $type : 'office',
            'name' => $name,
            'description' => (string)$this->request->getPost('description'),
        ];

        // Only books have grade range
        if ($data['type'] === 'book') {
            $gmin = $this->request->getPost('grade_min');
            $gmax = $this->request->getPost('grade_max');

            $gmin = ($gmin === '' || $gmin === null) ? null : max(0, (int)$gmin);
            $gmax = ($gmax === '' || $gmax === null) ? null : max(0, (int)$gmax);

            if ($gmin !== null && $gmax !== null && $gmin > $gmax) {
                return $this->error('Grade Min cannot be greater than Grade Max.', Response::HTTP_UNPROCESSABLE_ENTITY);
            }
            if ($gmin !== null && $gmin > 13) $gmin = 13;
            if ($gmax !== null && $gmax > 13) $gmax = 13;

            $data['grade_min'] = $gmin;
            $data['grade_max'] = $gmax;
        } else {
            $data['grade_min'] = null;
            $data['grade_max'] = null;
        }

        // Duplicate guard for (type, name) pair
        $existing = $this->cat
            ->where('type', $data['type'])
            ->where('name', $data['name'])
            ->first();

        try {
            if ($id) {
                $pk = $this->cat->primaryKey ?? 'id';
                if ($existing && (int)$existing[$pk] !== (int)$id) {
                    return $this->error(
                        'A category with this Type & Name already exists. Please choose a different name or edit the existing one.',
                        Response::HTTP_CONFLICT
                    );
                }
                $ok = $this->cat->update((int)$id, $data);
            } else {
                if ($existing) {
                    return $this->error(
                        'This category already exists: ' . $data['type'] . ' — ' . $data['name'] . '.',
                        Response::HTTP_CONFLICT
                    );
                }
                $ok = (bool) $this->cat->insert($data);
            }
        } catch (\Throwable $e) {
            $msg = $e->getMessage();
            if (strpos($msg, 'Duplicate entry') !== false && strpos($msg, 'type_name') !== false) {
                return $this->error(
                    'Duplicate Type/Name. A category with this combination already exists.',
                    Response::HTTP_CONFLICT
                );
            }
            log_message('critical', 'Failed to save category: {msg}', ['msg' => $msg]);
            return $this->error('Failed to save category.', Response::HTTP_INTERNAL_SERVER_ERROR);
        }

        if (!$ok) {
            return $this->error('Failed to save category.', Response::HTTP_INTERNAL_SERVER_ERROR);
        }

        return $this->success(null, 'Category saved.');
    }

    /**
     * GET /api/v1/inventory/classroom/{id}/audit
     * Get audit form data for a classroom item
     */
    public function auditClassroomForm($itemId)
    {
        $item = $this->item->find($itemId);
        if (!$item || $item['type'] !== 'classroom') {
            return $this->error('Invalid classroom item.', Response::HTTP_NOT_FOUND);
        }

        $item['good_qty'] = (int)($item['good_qty'] ?? 0);
        $item['needs_repair_qty'] = (int)($item['needs_repair_qty'] ?? 0);
        $item['need_replace_qty'] = (int)($item['need_replace_qty'] ?? 0);
        $item['cannot_find_qty'] = (int)($item['cannot_find_qty'] ?? 0);

        return $this->success(['item' => $item], 'Audit form data retrieved successfully');
    }

    /**
     * POST /api/v1/inventory/classroom/{id}/audit
     * Save audit data for a classroom item
     */
    public function auditClassroomStore($itemId)
    {
        $item = $this->item->find($itemId);
        if (!$item || $item['type'] !== 'classroom') {
            return $this->error('Invalid classroom item.', Response::HTTP_NOT_FOUND);
        }

        $prevGood = (int)($item['good_qty'] ?? 0);
        $prevRepair = (int)($item['needs_repair_qty'] ?? 0);
        $prevLoss = (int)($item['need_replace_qty'] ?? 0);
        $prevMiss = (int)($item['cannot_find_qty'] ?? 0);

        $newRepair = max(0, (int)$this->request->getPost('needs_repair_qty'));
        $newLoss = max(0, (int)$this->request->getPost('need_replace_qty'));
        $newMiss = max(0, (int)$this->request->getPost('cannot_find_qty'));

        $onHandNow = (int)$item['quantity'];
        $newGood = max(0, $onHandNow - $newRepair);

        $deltaLoss = $newLoss - $prevLoss;
        $deltaMiss = $newMiss - $prevMiss;

        $totalOut = 0;
        if ($deltaLoss > 0) $totalOut += $deltaLoss;
        if ($deltaMiss > 0) $totalOut += $deltaMiss;

        $totalIn = 0;
        if ($deltaLoss < 0) $totalIn += -$deltaLoss;
        if ($deltaMiss < 0) $totalIn += -$deltaMiss;

        if ($totalOut > 0) {
            if (!$this->recordMovement($itemId, -$totalOut, 'out', 'Audit: loss/missing increased')) {
                return $this->error('Failed to record movement', Response::HTTP_INTERNAL_SERVER_ERROR);
            }
        }
        if ($totalIn > 0) {
            $this->recordMovement($itemId, +$totalIn, 'in', 'Audit: loss/missing decreased');
        }

        $this->recalcQuantity($itemId);

        try {
            $this->item->update($itemId, [
                'good_qty' => $newGood,
                'needs_repair_qty' => $newRepair,
                'need_replace_qty' => $newLoss,
                'cannot_find_qty' => $newMiss,
                'updated_by' => $this->getCurrentUserId(),
                'updated_at' => utc_now(),
            ]);
            return $this->success(null, 'Audit saved.');
        } catch (\Throwable $e) {
            log_message('error', 'Audit save error: ' . $e->getMessage());
            return $this->error('Failed to save audit: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * GET /api/v1/inventory/summary/{type?}
     * Get inventory summary for a type
     */
    public function summary($type = 'classroom')
    {
        $type = $this->normalizeType($type);
        $currentSem = $this->semester;
        $currentYear = $this->schoolYear;
        $selectedYear = trim((string) ($this->request->getGet('school_year') ?? '')) ?: $currentYear;

        $items = $this->item->where('type', $type)->orderBy('name', 'ASC')->findAll();
        $itemIds = array_map(fn($i) => (int)$i['id'], $items);

        $agg = [];
        if ($itemIds) {
            $qb = $this->mov->select('item_id,
             SUM(CASE WHEN qty_change>0 THEN qty_change ELSE 0 END) AS received,
             SUM(CASE WHEN qty_change<0 THEN -qty_change ELSE 0 END) AS issued')
                ->whereIn('item_id', $itemIds)
                ->groupBy('item_id');

            if (strtolower($selectedYear) !== 'all') {
                $qb->where('school_year', $selectedYear);
            }

            foreach ($qb->findAll() as $row) {
                $agg[(int)$row['item_id']] = [
                    'received' => (int)$row['received'],
                    'issued' => (int)$row['issued'],
                ];
            }
        }

        $schoolYears = $this->getSchoolYearsForType($type);

        return $this->success([
            'type' => $type,
            'items' => $items,
            'agg' => $agg,
            'selectedYear' => $selectedYear,
            'currentYear' => $currentYear,
            'schoolYears' => $schoolYears,
        ], 'Summary retrieved successfully');
    }

    /**
     * GET /api/v1/inventory/summary-all
     * Get comprehensive inventory summary across all types
     */
    public function summaryAll()
    {
        $selectedYear = trim((string) ($this->request->getGet('school_year') ?? '')) ?: (string) $this->schoolYear;
        $selectedType = strtolower((string) ($this->request->getGet('type') ?? 'all'));
        $isAllYears = (strtolower($selectedYear) === 'all');

        $qbItems = DB::table('inventory_items i')
            ->select('i.*, c.name AS category_name, CONCAT(u.firstname, " ", u.lastname) AS updated_by_name')
            ->leftJoin('inventory_categories c', 'c.id', '=', 'i.category_id')
            ->leftJoin('users u', 'u.id', '=', 'i.updated_by')
            ->orderBy('i.name', 'ASC');

        if (!$isAllYears) {
            $qbItems->where('i.school_year', $selectedYear);
        }

        if (in_array($selectedType, ['book', 'classroom', 'office', 'kitchen'], true)) {
            $qbItems->where('i.type', $selectedType);
        }

        $items = $qbItems->get()->toArray();

        $rows = [];
        $totals = [
            'opening' => 0,
            'received' => 0,
            'distributed' => 0,
            'other_out' => 0,
            'adjust_net' => 0,
            'ending' => 0,
            'onhand' => 0,
            'variance' => 0,
        ];

        if (empty($items)) {
            return $this->success([
                'selectedYear' => $selectedYear,
                'currentYear' => $this->schoolYear,
                'schoolYears' => $this->getSchoolYearsForType('book') ?: [$this->schoolYear, 'All'],
                'rows' => $rows,
                'totals' => $totals,
                'selectedType' => $selectedType,
            ], 'Summary retrieved successfully');
        }

        $itemIds = array_map('intval', array_column($items, 'id'));

        $aggById = [];
        $qb = DB::table('inventory_movements m')
            ->select(DB::raw("
                m.item_id,
                SUM(CASE WHEN m.movement_type = 'initial' THEN m.qty_change ELSE 0 END) AS opening,
                SUM(CASE WHEN m.qty_change > 0 AND m.movement_type IN ('in','adjust') THEN m.qty_change ELSE 0 END) AS received,
                SUM(CASE WHEN m.qty_change < 0 AND m.movement_type = 'distribution' THEN -m.qty_change ELSE 0 END) AS distributed,
                SUM(CASE WHEN m.qty_change < 0 AND m.movement_type = 'out' THEN -m.qty_change ELSE 0 END) AS other_out,
                SUM(CASE WHEN m.movement_type = 'adjust' THEN m.qty_change ELSE 0 END) AS adjust_net
            "))
            ->whereIn('m.item_id', $itemIds)
            ->groupBy('m.item_id');

        if (!$isAllYears) {
            $qb->where('m.school_year', $selectedYear);
        }

        foreach ($qb->get()->toArray() as $r) {
            $aggById[(int)$r->item_id] = [
                'opening' => (int)($r->opening ?? 0),
                'received' => (int)($r->received ?? 0),
                'distributed' => (int)($r->distributed ?? 0),
                'other_out' => (int)($r->other_out ?? 0),
                'adjust_net' => (int)($r->adjust_net ?? 0),
            ];
        }

        foreach ($items as $it) {
            $it = (array)$it;
            $id = (int)$it['id'];
            $a = $aggById[$id] ?? ['opening' => 0, 'received' => 0, 'distributed' => 0, 'other_out' => 0, 'adjust_net' => 0];

            $opening = (int)$a['opening'];
            $received = (int)$a['received'];
            $distributed = (int)$a['distributed'];
            $otherOut = (int)$a['other_out'];
            $adjustNet = (int)$a['adjust_net'];

            $ending = $opening + $received - $distributed - $otherOut + $adjustNet;
            $onhand = (int)$it['quantity'];
            $variance = $onhand - $ending;

            $rows[] = [
                'id' => $id,
                'name' => (string)$it['name'],
                'type' => (string)$it['type'],
                'category' => (string)($it['category_name'] ?? ''),
                'opening' => $opening,
                'received' => $received,
                'distributed' => $distributed,
                'other_out' => $otherOut,
                'adjust_net' => $adjustNet,
                'ending' => $ending,
                'onhand' => $onhand,
                'variance' => $variance,
            ];

            $totals['opening'] += $opening;
            $totals['received'] += $received;
            $totals['distributed'] += $distributed;
            $totals['other_out'] += $otherOut;
            $totals['adjust_net'] += $adjustNet;
            $totals['ending'] += $ending;
            $totals['onhand'] += $onhand;
            $totals['variance'] += $variance;
        }

        $schoolYears = $this->getSchoolYearsForType('book') ?: [$this->schoolYear, 'All'];

        return $this->success([
            'selectedYear' => $selectedYear,
            'currentYear' => $this->schoolYear,
            'schoolYears' => $schoolYears,
            'rows' => $rows,
            'totals' => $totals,
            'selectedType' => $selectedType,
        ], 'Summary retrieved successfully');
    }

    /**
     * GET /api/v1/inventory/{id}/adjust
     * Get adjust form data
     */
    public function adjustForm($itemId)
    {
        $item = $this->item->find($itemId);
        if (!$item) {
            return $this->error('Item not found.', Response::HTTP_NOT_FOUND);
        }
        return $this->success(['item' => $item, 'type' => $item['type']], 'Adjust form data retrieved successfully');
    }

    /**
     * POST /api/v1/inventory/{id}/adjust
     * Adjust inventory quantity
     */
    public function adjustStore($itemId)
    {
        $item = $this->item->find($itemId);
        if (!$item) {
            return $this->error('Item not found.', Response::HTTP_NOT_FOUND);
        }

        $mode = $this->request->getPost('mode');
        $qty = (int) $this->request->getPost('quantity');
        $reason = (string) $this->request->getPost('reason');
        $note = (string) $this->request->getPost('note');

        if ($qty <= 0) {
            return $this->error('Quantity must be > 0.', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        $delta = ($mode === 'out') ? -abs($qty) : (($mode === 'in') ? abs($qty) : $qty);
        $type = ($mode === 'out') ? 'out' : (($mode === 'in') ? 'in' : 'adjust');

        if (!$this->recordMovement((int)$itemId, $delta, $type, $reason, $note)) {
            return $this->error('Failed to record movement', Response::HTTP_INTERNAL_SERVER_ERROR);
        }

        return $this->success(['type' => $item['type']], 'Stock updated.');
    }

    /**
     * GET /api/v1/inventory/books/distribute
     * Get teacher book distribution form data
     */
    public function teacherDistributeForm()
    {
        $ctx = $this->buildTeacherClassContext();
        if (is_array($ctx) && isset($ctx['error'])) {
            return $this->error($ctx['error'], $ctx['code'] ?? Response::HTTP_UNAUTHORIZED);
        }

        $lockClassSection = is_array($ctx['classSectionIds'] ?? null) && count($ctx['classSectionIds']) === 1;
        $classSectionId = $lockClassSection
            ? (int) ($ctx['defaultClassSectionId'] ?? 0)
            : (int) ($this->request->getGet('class_section_id') ?? ($ctx['defaultClassSectionId'] ?? 0));

        $classID = null;
        if (!empty($classSectionId)) {
            $classID = $this->classSection->getClassId($classSectionId);
            if ($classID !== null) $classID = (int) $classID;
        }

        $itemId = (int) ($this->request->getGet('item_id') ?? 0);

        $db = DB::connection();
        $builder = $db->table('inventory_items i')
            ->select('i.id,i.name,i.isbn,i.edition,i.quantity,i.category_id,i.type,
                  c.name AS category_name, c.grade_min, c.grade_max')
            ->leftJoin('inventory_categories c', 'c.id', '=', 'i.category_id')
            ->where('i.type', 'book');

        if (!empty($classID)) {
            $builder->where(function($query) use ($classID) {
                $query->where(function($q) use ($classID) {
                    $q->whereNotNull('c.grade_min')
                      ->whereNotNull('c.grade_max')
                      ->where('c.grade_min', '<=', (int)$classID)
                      ->where('c.grade_max', '>=', (int)$classID);
                })
                ->orWhere(function($q) use ($classID) {
                    $q->whereNotNull('c.grade_min')
                      ->whereNull('c.grade_max')
                      ->where('c.grade_min', (int)$classID);
                })
                ->orWhere(function($q) use ($classID) {
                    $q->whereNotNull('c.grade_max')
                      ->whereNull('c.grade_min')
                      ->where('c.grade_max', (int)$classID);
                });
            });
        }

        $rows = $builder->orderBy('i.name', 'ASC')->get()->toArray();

        $labelFor = static function (?array $r): string {
            $name = $r['category_name'] ?? 'Uncategorized';
            $gmin = $r['grade_min'] ?? null;
            $gmax = $r['grade_max'] ?? null;
            if ($gmin === null && $gmax === null) return $name;
            if ($gmin !== null && $gmax !== null) return $name . ' (G' . (int)$gmin . '–G' . (int)$gmax . ')';
            if ($gmin !== null) return $name . ' (G' . (int)$gmin . '+)';
            return $name . ' (≤G' . (int)$gmax . ')';
        };

        $booksGrouped = [];
        foreach ($rows as $r) {
            $r = (array)$r;
            $catId = (int)($r['category_id'] ?? 0);
            if (!isset($booksGrouped[$catId])) {
                $booksGrouped[$catId] = [
                    'label' => $labelFor($r),
                    'items' => [],
                ];
            }
            $display = $r['name'];
            if (!empty($r['isbn'])) $display .= ' — ISBN ' . $r['isbn'];
            if (!empty($r['edition'])) $display .= ' (' . $r['edition'] . ')';

            $booksGrouped[$catId]['items'][] = [
                'id' => (int)$r['id'],
                'display' => $display,
                'quantity' => (int)($r['quantity'] ?? 0),
            ];
        }

        uasort($booksGrouped, fn($a, $b) => strnatcasecmp($a['label'], $b['label']));
        foreach ($booksGrouped as &$grp) {
            usort($grp['items'], fn($x, $y) => strnatcasecmp($x['display'], $y['display']));
        }
        unset($grp);

        $students = $ctx['studentsData'][$classSectionId] ?? [];

        $already = [];
        if ($itemId && $classSectionId) {
            $rowsHist = $this->mov
                ->select('student_id, SUM(CASE WHEN qty_change < 0 THEN -qty_change ELSE 0 END) AS qty')
                ->where([
                    'item_id' => $itemId,
                    'movement_type' => 'distribution',
                    'class_section_id' => $classSectionId,
                    'school_year' => $ctx['schoolYear'],
                ])
                ->groupBy('student_id')
                ->findAll();

            foreach ($rowsHist as $r) {
                $sid = (int) ($r['student_id'] ?? 0);
                if ($sid) $already[$sid] = (int) ($r['qty'] ?? 0);
            }
        }

        $onHand = 0;
        if ($itemId) {
            $book = $this->item->find($itemId);
            if ($book && ($book['type'] ?? '') === 'book') {
                $onHand = (int) ($book['quantity'] ?? 0);
            }
        }

        return $this->success([
            'booksGrouped' => $booksGrouped,
            'items' => $rows,
            'classes' => $ctx['classes'],
            'class_section_id' => $classSectionId,
            'lockClassSection' => $lockClassSection,
            'item_id' => $itemId,
            'students' => $students,
            'already' => $already,
            'onHand' => $onHand,
            'schoolYear' => $ctx['schoolYear'],
            'semester' => $ctx['semester'],
        ], 'Distribution form data retrieved successfully');
    }

    /**
     * POST /api/v1/inventory/books/distribute
     * Distribute books to students
     */
    public function teacherDistributeStore()
    {
        $ctx = $this->buildTeacherClassContext();
        if (is_array($ctx) && isset($ctx['error'])) {
            return $this->error($ctx['error'], $ctx['code'] ?? Response::HTTP_UNAUTHORIZED);
        }

        $itemId = (int)$this->request->getPost('item_id');
        $postedClassId = (int)$this->request->getPost('class_section_id');
        $selectedIds = (array)$this->request->getPost('student_ids');
        $note = (string)$this->request->getPost('note');

        $classIds = $ctx['classSectionIds'];
        $classSectionId = (count($classIds) === 1)
            ? (int)$classIds[0]
            : (in_array($postedClassId, $classIds, true) ? $postedClassId : 0);

        if (!$classSectionId) {
            return $this->error('Invalid class selection.', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        $book = $this->item->find($itemId);
        if (!$book || $book['type'] !== 'book') {
            return $this->error('Invalid book.', Response::HTTP_NOT_FOUND);
        }

        $students = $ctx['studentsData'][$classSectionId] ?? [];
        $validIds = [];
        foreach ($students as $st) {
            $sid = $st['student_id'] ?? ($st['id'] ?? ($st['user_id'] ?? null));
            if ($sid) $validIds[(int)$sid] = true;
        }
        $selectedIds = array_values(array_unique(array_map('intval', $selectedIds)));
        $selectedIds = array_values(array_filter($selectedIds, fn($sid) => isset($validIds[$sid])));

        $already = [];
        $rows = $this->mov
            ->select('student_id, SUM(CASE WHEN qty_change < 0 THEN -qty_change ELSE 0 END) AS qty')
            ->where([
                'item_id' => $itemId,
                'movement_type' => 'distribution',
                'class_section_id' => $classSectionId,
                'school_year' => $ctx['schoolYear'],
            ])->groupBy('student_id')->findAll();
        foreach ($rows as $r) {
            $sid = (int)($r['student_id'] ?? 0);
            if ($sid) $already[$sid] = (int)$r['qty'];
        }

        $toGive = [];
        foreach ($selectedIds as $sid) {
            if (($already[$sid] ?? 0) < 1) $toGive[] = $sid;
        }

        $needed = count($toGive);
        $onHand = (int)$book['quantity'];

        if ($needed > $onHand) {
            return $this->error('Not enough stock: need ' . $needed . ', on hand ' . $onHand . '.', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        $okCount = 0;
        foreach ($toGive as $sid) {
            $ok = $this->recordMovement($itemId, -1, 'distribution', 'Teacher distribution', $note, $classSectionId, $sid);
            if ($ok) $okCount++;
        }

        if ($okCount === 0) {
            return $this->error('No changes (everyone selected already has this book).', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        return $this->success(['distributed_count' => $okCount], 'Distributed to ' . $okCount . ' student(s).');
    }

    /**
     * GET /api/v1/inventory/movements
     * List inventory movements
     */
    public function movementsIndex()
    {
        $selectedYear = (string)($this->request->getGet('school_year') ?? '');
        $selectedSem = (string)($this->request->getGet('semester') ?? '');

        $builder = DB::table('inventory_movements m')
            ->select([
                'm.*',
                'ii.name AS item_name',
                DB::raw("CONCAT(pb.firstname, ' ', pb.lastname) AS performed_by_name"),
                DB::raw("CONCAT(t.firstname, ' ', t.lastname) AS teacher_name"),
                DB::raw("CONCAT(s.firstname, ' ', s.lastname) AS student_name"),
                'cs.class_section_name',
            ])
            ->leftJoin('inventory_items ii', 'ii.id', '=', 'm.item_id')
            ->leftJoin('users pb', 'pb.id', '=', 'm.performed_by')
            ->leftJoin('users t', 't.id', '=', 'm.teacher_id')
            ->leftJoin('students s', 's.id', '=', 'm.student_id')
            ->leftJoin('classSection cs', 'cs.class_section_id', '=', 'm.class_section_id')
            ->orderBy('m.id', 'DESC');

        if ($selectedYear !== '') $builder->where('m.school_year', $selectedYear);
        if ($selectedSem !== '') $builder->where('m.semester', $selectedSem);

        $movements = $builder->get()->toArray();

        return $this->success([
            'movements' => $movements,
            'schoolYear' => $selectedYear,
            'semester' => $selectedSem,
        ], 'Movements retrieved successfully');
    }

    /**
     * GET /api/v1/inventory/movements/create
     * Get form data for creating a movement
     */
    public function movementsCreate()
    {
        return $this->success([
            'movement' => $this->blankMovement(),
            'movementTypes' => $this->movementTypes,
            'semesters' => $this->semesters,
            'items' => $this->getItems(),
            'classSections' => $this->getClassSections(),
            'teachers' => $this->getTeachers(),
            'students' => $this->getStudents(),
        ], 'Form data retrieved successfully');
    }

    /**
     * POST /api/v1/inventory/movements
     * Create a movement
     */
    public function movementsStore()
    {
        $rules = [
            'item_id' => 'required|integer',
            'qty_change' => 'required|integer',
            'movement_type' => 'required|in_list[' . implode(',', $this->movementTypes) . ']',
            'reason' => 'permit_empty|max_length[120]',
            'note' => 'permit_empty|string',
            'semester' => 'permit_empty|in_list[' . implode(',', $this->semesters) . ']',
            'school_year' => 'permit_empty|max_length[16]',
            'teacher_id' => 'permit_empty|integer',
            'student_id' => 'permit_empty|integer',
            'class_section_id' => 'permit_empty|integer',
        ];

        $payload = $this->payloadData();
        $errors = $this->validateRequest($payload, $rules);
        if (!empty($errors)) {
            return $this->respondValidationError($errors);
        }

        $userId = (int) ($this->getCurrentUserId() ?? 0);

        $data = [
            'item_id' => (int) $payload['item_id'],
            'qty_change' => (int) $payload['qty_change'],
            'movement_type' => $payload['movement_type'],
            'reason' => trim((string)($payload['reason'] ?? '')),
            'note' => trim((string)($payload['note'] ?? '')),
            'semester' => $payload['semester'] ?? null,
            'school_year' => $payload['school_year'] ?? null,
            'performed_by' => $userId ?: null,
            'teacher_id' => $this->nullableInt($payload['teacher_id'] ?? null),
            'student_id' => $this->nullableInt($payload['student_id'] ?? null),
            'class_section_id' => $this->nullableInt($payload['class_section_id'] ?? null),
            'created_at' => utc_now(),
            'updated_at' => utc_now(),
        ];

        try {
            $ok = DB::table('inventory_movements')->insert($data);
            if (!$ok) {
                return $this->error('Could not save movement.', Response::HTTP_INTERNAL_SERVER_ERROR);
            }
            return $this->respondCreated($data, 'Movement created.');
        } catch (\Throwable $e) {
            log_message('error', 'Movement creation error: ' . $e->getMessage());
            return $this->error('Could not save movement: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * GET /api/v1/inventory/movements/{id}
     * Get a single movement
     */
    public function movementsEdit($id)
    {
        $movement = DB::table('inventory_movements')->where('id', $id)->first();
        if (!$movement) {
            return $this->error('Movement not found.', Response::HTTP_NOT_FOUND);
        }

        $movement = $this->hydrateNames((array)$movement);

        return $this->success([
            'movement' => $movement,
            'movementTypes' => $this->movementTypes,
            'semesters' => $this->semesters,
            'items' => $this->getItems(),
            'classSections' => $this->getClassSections(),
            'teachers' => $this->getTeachers(),
            'students' => $this->getStudents(),
        ], 'Movement retrieved successfully');
    }

    /**
     * PATCH /api/v1/inventory/movements/{id}
     * Update a movement
     */
    public function movementsUpdate($id)
    {
        $rules = [
            'qty_change' => 'required|integer',
            'movement_type' => 'required|in_list[' . implode(',', $this->movementTypes) . ']',
            'reason' => 'permit_empty|max_length[120]',
            'note' => 'permit_empty|string',
            'semester' => 'permit_empty|in_list[' . implode(',', $this->semesters) . ']',
            'school_year' => 'permit_empty|max_length[16]',
            'teacher_id' => 'permit_empty|integer',
            'student_id' => 'permit_empty|integer',
            'class_section_id' => 'permit_empty|integer',
        ];

        $payload = $this->payloadData();
        $errors = $this->validateRequest($payload, $rules);
        if (!empty($errors)) {
            return $this->respondValidationError($errors);
        }

        $existing = DB::table('inventory_movements')->where('id', $id)->first();
        if (!$existing) {
            return $this->error('Movement not found.', Response::HTTP_NOT_FOUND);
        }

        $data = [
            'qty_change' => (int) $payload['qty_change'],
            'movement_type' => $payload['movement_type'],
            'reason' => trim((string)($payload['reason'] ?? '')),
            'note' => trim((string)($payload['note'] ?? '')),
            'semester' => $payload['semester'] ?? null,
            'school_year' => $payload['school_year'] ?? null,
            'teacher_id' => $this->nullableInt($payload['teacher_id'] ?? null),
            'student_id' => $this->nullableInt($payload['student_id'] ?? null),
            'class_section_id' => $this->nullableInt($payload['class_section_id'] ?? null),
            'updated_at' => utc_now(),
        ];

        try {
            $ok = DB::table('inventory_movements')->where('id', $id)->update($data);
            if (!$ok) {
                return $this->error('Could not update movement.', Response::HTTP_INTERNAL_SERVER_ERROR);
            }
            $updated = DB::table('inventory_movements')->where('id', $id)->first();
            return $this->success($updated, 'Movement updated.');
        } catch (\Throwable $e) {
            log_message('error', 'Movement update error: ' . $e->getMessage());
            return $this->error('Could not update movement: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * DELETE /api/v1/inventory/movements/{id}
     * Delete a movement
     */
    public function movementsDelete($id)
    {
        log_message('info', 'Inventory: delete one attempt', ['id' => $id, 'user' => (int)($this->getCurrentUserId() ?? 0)]);
        try {
            $ok = DB::table('inventory_movements')->where('id', $id)->delete();
            log_message('info', 'Inventory: delete one result', ['id' => $id, 'ok' => (bool)$ok]);
            if (!$ok) {
                return $this->error('Could not delete movement.', Response::HTTP_INTERNAL_SERVER_ERROR);
            }
            return $this->success(null, 'Movement deleted.');
        } catch (\Throwable $e) {
            log_message('error', 'Movement deletion error: ' . $e->getMessage());
            return $this->error('Could not delete movement: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * POST /api/v1/inventory/movements/bulk-delete
     * Bulk delete movements
     */
    public function movementsBulkDelete()
    {
        $ids = (array) $this->request->getPost('ids');
        $ids = array_values(array_filter(array_map('intval', $ids), fn($v) => $v > 0));

        if (empty($ids)) {
            log_message('warning', 'Inventory: bulk delete called with empty ids', ['user' => (int)($this->getCurrentUserId() ?? 0)]);
            return $this->error('No movements selected.', Response::HTTP_BAD_REQUEST);
        }

        log_message('info', 'Inventory: bulk delete attempt', ['count' => count($ids), 'ids' => $ids, 'user' => (int)($this->getCurrentUserId() ?? 0)]);
        try {
            $ok = DB::table('inventory_movements')->whereIn('id', $ids)->delete();
            log_message('info', 'Inventory: bulk delete result', ['ok' => (bool)$ok]);
            if (!$ok) {
                return $this->error('Bulk delete failed.', Response::HTTP_INTERNAL_SERVER_ERROR);
            }
            return $this->success(['deleted_count' => count($ids)], count($ids) . ' movement(s) deleted.');
        } catch (\Throwable $e) {
            log_message('error', 'Bulk delete error: ' . $e->getMessage());
            return $this->error('Bulk delete failed: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    // ========== Private Helper Methods ==========

    private function normalizeType(?string $type): string
    {
        $type = strtolower((string)$type);
        return in_array($type, $this->types, true) ? $type : 'classroom';
    }

    private function filterItemData(array $data, ?string $lockedType = null): array
    {
        $type = $lockedType ?? $this->normalizeType($data['type'] ?? 'classroom');

        $qtyRaw = $data['quantity'] ?? null;
        $quantity = is_numeric($qtyRaw) ? (int)$qtyRaw : 0;

        $base = [
            'type' => $type,
            'category_id' => (isset($data['category_id']) && $data['category_id'] !== null && $data['category_id'] !== '') ? (int)$data['category_id'] : null,
            'name' => (string) ($data['name'] ?? ''),
            'description' => $data['description'] ?? null,
            'quantity' => $quantity,
            'unit' => $data['unit'] ?? null,
            'sku' => $data['sku'] ?? null,
            'notes' => $data['notes'] ?? null,
            'semester' => $this->semester,
            'school_year' => $this->schoolYear,
            'updated_by' => $this->getCurrentUserId(),
        ];

        $base['condition'] = ($type === 'classroom') ? ($data['condition'] ?? null) : null;

        if ($type === 'book') {
            $base['isbn'] = $data['isbn'] ?? null;
            $base['edition'] = $data['edition'] ?? null;
        } else {
            $base['isbn'] = $base['edition'] = null;
        }

        return $base;
    }

    private function ensureInitialMovement(int $itemId): void
    {
        $hasMov = $this->mov->where('item_id', $itemId)->limit(1)->countAllResults();
        if ($hasMov > 0) return;

        $item = $this->item->select('quantity')->find($itemId);
        $initialQty = (int)($item['quantity'] ?? 0);

        $this->mov->insert([
            'item_id' => $itemId,
            'qty_change' => $initialQty,
            'movement_type' => 'initial',
            'semester' => $this->semester,
            'school_year' => $this->schoolYear,
            'performed_by' => $this->getCurrentUserId(),
        ], false);
    }

    private function recordMovement(
        int $itemId,
        int $qtyChange,
        string $type,
        ?string $reason = null,
        ?string $note = null,
        ?int $classSectionId = null,
        ?int $studentId = null
    ): bool {
        $me = $this->getCurrentUserId();
        $isInitial = ($type === 'initial');

        if (!$isInitial) {
            $this->ensureInitialMovement($itemId);
            $this->ensureInitialMovementForYear($itemId, $this->schoolYear);
            $this->recalcQuantity($itemId);
        }

        if (in_array($type, ['out', 'distribution'], true) && $qtyChange > 0) {
            $qtyChange = -abs($qtyChange);
        }

        if (in_array($type, ['out', 'distribution'], true)) {
            $onHand = (int) ($this->item->select('quantity')->where('id', $itemId)->first()['quantity'] ?? 0);
            if ($onHand + $qtyChange < 0) {
                return false;
            }
        }

        $ok = $this->mov->insert([
            'item_id' => $itemId,
            'qty_change' => $qtyChange,
            'movement_type' => $type,
            'reason' => $reason,
            'note' => $note,
            'semester' => $this->semester,
            'school_year' => $this->schoolYear,
            'performed_by' => $me,
            'teacher_id' => $me,
            'student_id' => $studentId,
            'class_section_id' => $classSectionId,
        ], false);

        if ($ok) {
            $this->recalcQuantity($itemId);
            return true;
        }
        return false;
    }

    private function recalcQuantity(int $itemId): void
    {
        $sumRow = $this->mov
            ->selectSum('qty_change')
            ->where('item_id', $itemId)
            ->first();

        $sum = (int)($sumRow['qty_change'] ?? 0);
        if ($sum < 0) $sum = 0;

        $item = $this->item
            ->select('id, type, quantity, needs_repair_qty, good_qty')
            ->find($itemId);

        if (!$item) return;

        $updates = [];

        if ((int)$item['quantity'] !== $sum) {
            $updates['quantity'] = $sum;
        }

        if (($item['type'] ?? null) === 'classroom') {
            $needsRepair = (int)($item['needs_repair_qty'] ?? 0);
            $goodCalc = max(0, $sum - $needsRepair);
            if (!array_key_exists('good_qty', $item) || (int)$item['good_qty'] !== $goodCalc) {
                $updates['good_qty'] = $goodCalc;
            }
        }

        if (!empty($updates)) {
            try {
                $this->item->update($itemId, $updates);
            } catch (\Throwable $e) {
                log_message('error', 'recalcQuantity() skipped update: ' . $e->getMessage());
            }
        }
    }

    private function userNamesByIds(array $ids): array
    {
        $ids = array_values(array_unique(array_filter($ids, fn($v) => !empty($v))));
        if (!$ids) return [];

        if (!DB::getSchemaBuilder()->hasTable('users')) return [];

        $cols = DB::getSchemaBuilder()->getColumnListing('users');
        $hasFirst = in_array('first_name', $cols, true) || in_array('firstname', $cols, true);
        $hasLast = in_array('last_name', $cols, true) || in_array('lastname', $cols, true);
        $firstCol = in_array('first_name', $cols, true) ? 'first_name' : (in_array('firstname', $cols, true) ? 'firstname' : null);
        $lastCol = in_array('last_name', $cols, true) ? 'last_name' : (in_array('lastname', $cols, true) ? 'lastname' : null);
        $nameCol = in_array('name', $cols, true) ? 'name' : null;
        $emailCol = in_array('email', $cols, true) ? 'email' : null;

        if ($firstCol || $lastCol) {
            $select = "id, TRIM(CONCAT(IFNULL($firstCol,''),' ',IFNULL($lastCol,''))) AS display_name";
        } elseif ($nameCol) {
            $select = "id, $nameCol AS display_name";
        } elseif ($emailCol) {
            $select = "id, $emailCol AS display_name";
        } else {
            $out = [];
            foreach ($ids as $id) $out[(int)$id] = 'User #' . $id;
            return $out;
        }

        $rows = DB::table('users')->select(DB::raw($select))->whereIn('id', $ids)->get()->toArray();
        $map = [];
        foreach ($rows as $r) {
            $r = (array)$r;
            $disp = trim((string)($r['display_name'] ?? ''));
            $map[(int)$r['id']] = $disp !== '' ? $disp : ('User #' . $r['id']);
        }
        return $map;
    }

    private function getSchoolYearsForType(string $type): array
    {
        $years = $this->item
            ->select('school_year')
            ->where('type', $type)
            ->whereRaw('school_year IS NOT NULL')
            ->groupBy('school_year')
            ->orderBy('school_year', 'DESC')
            ->pluck('school_year')
            ->toArray();

        $years = array_values(array_unique(array_filter(array_map('trim', $years))));

        $currentYear = $this->schoolYear;
        if ($currentYear && !in_array($currentYear, $years, true)) {
            array_unshift($years, $currentYear);
            $years = array_values(array_unique($years));
        }

        return $years;
    }

    private function ensureInitialMovementForYear(int $itemId, string $schoolYear): void
    {
        $hasAnyThisYear = $this->mov
            ->where('item_id', $itemId)
            ->where('school_year', $schoolYear)
            ->limit(1)->countAllResults();

        if ($hasAnyThisYear === 0) {
            $onHand = (int) ($this->item->select('quantity')->where('id', $itemId)->first()['quantity'] ?? 0);
            $this->mov->insert([
                'item_id' => $itemId,
                'qty_change' => $onHand,
                'movement_type' => 'initial',
                'school_year' => $schoolYear,
                'semester' => $this->semester ?? null,
                'performed_by' => $this->getCurrentUserId(),
            ], false);
            return;
        }

        $hasInitialThisYear = $this->mov
            ->where('item_id', $itemId)
            ->where('school_year', $schoolYear)
            ->where('movement_type', 'initial')
            ->limit(1)->countAllResults();

        if ($hasInitialThisYear === 0) {
            $onHand = (int) ($this->item->select('quantity')->where('id', $itemId)->first()['quantity'] ?? 0);
            $netYear = (int) ($this->mov->selectSum('qty_change')
                ->where('item_id', $itemId)
                ->where('school_year', $schoolYear)
                ->first()['qty_change'] ?? 0);

            $opening = $onHand - $netYear;
            $this->mov->insert([
                'item_id' => $itemId,
                'qty_change' => $opening,
                'movement_type' => 'initial',
                'school_year' => $schoolYear,
                'semester' => $this->semester ?? null,
                'performed_by' => $this->getCurrentUserId(),
            ], false);
        }
    }

    private function buildTeacherClassContext()
    {
        $user_id = $this->getCurrentUserId();
        if (!$user_id) {
            return ['error' => 'Please log in first', 'code' => Response::HTTP_UNAUTHORIZED];
        }

        $classes = $this->teacherClass->getClassAssignmentsByUserId($user_id, $this->schoolYear);

        if (empty($classes)) {
            return ['error' => 'You do not have an assigned class yet. Please contact the administration.', 'code' => Response::HTTP_FORBIDDEN];
        }

        $user = $this->user->find($user_id);
        if (!$user) {
            return ['error' => 'User not found', 'code' => Response::HTTP_NOT_FOUND];
        }

        $roles = DB::table('user_roles ur')
            ->select('r.name')
            ->join('roles r', 'r.id', '=', 'ur.role_id')
            ->where('ur.user_id', $user_id)
            ->get()->toArray();

        $roleNames = array_map(fn($r) => $r->name, $roles);

        if (in_array('teacher', $roleNames, true)) {
            $user['role_name'] = 'teacher';
        } elseif (in_array('teacher_assistant', $roleNames, true)) {
            $user['role_name'] = 'teacher_assistant';
        } else {
            return ['error' => 'Access denied', 'code' => Response::HTTP_FORBIDDEN];
        }

        $classSectionIds = array_column($classes, 'class_section_id');
        $studentsData = [];

        if (!empty($classSectionIds)) {
            $students = $this->studentClass->getStudentsByClassSectionIds($classSectionIds);
            foreach ($students as $student) {
                $studentsData[$student['class_section_id']][] = $student;
            }
        }

        $taAssignments = $this->teacherClass
            ->whereIn('class_section_id', $classSectionIds)
            ->where('school_year', $this->schoolYear)
            ->where('position', 'ta')
            ->findAll();

        $taNames = [];
        foreach ($taAssignments as $ta) {
            $taUser = $this->user->find($ta['teacher_id']);
            if ($taUser) {
                $csid = $ta['class_section_id'];
                $taNames[$csid][] = ($taUser['firstname'] ?? '') . ' ' . ($taUser['lastname'] ?? '');
            }
        }

        $defaultClassSectionId = $classSectionIds[0] ?? null;

        return [
            'user' => $user,
            'roleNames' => $roleNames,
            'classes' => $classes,
            'classSectionIds' => $classSectionIds,
            'studentsData' => $studentsData,
            'taNames' => $taNames,
            'defaultClassSectionId' => $defaultClassSectionId,
            'schoolYear' => $this->schoolYear,
            'semester' => $this->semester,
            'user_id' => $user_id,
        ];
    }

    private function blankMovement(): array
    {
        return [
            'id' => null,
            'item_id' => null,
            'qty_change' => 0,
            'movement_type' => 'adjust',
            'reason' => '',
            'note' => '',
            'semester' => null,
            'school_year' => null,
            'performed_by' => $this->getCurrentUserId(),
            'teacher_id' => null,
            'student_id' => null,
            'class_section_id' => null,
            'created_at' => null,
            'updated_at' => null,
        ];
    }

    private function nullableInt($val): ?int
    {
        if ($val === null || $val === '' || $val === '0') {
            return null;
        }
        return (int) $val;
    }

    private function hydrateNames(array $m): array
    {
        if (!empty($m['item_id'])) {
            $row = DB::table('inventory_items')->select('name')->where('id', $m['item_id'])->first();
            $m['item_name'] = $row->name ?? null;
        }

        if (!empty($m['performed_by'])) {
            $row = DB::table('users')
                ->select(DB::raw("CONCAT(firstname, ' ', lastname) AS fullname"))
                ->where('id', $m['performed_by'])
                ->first();
            $m['performed_by_name'] = $row->fullname ?? null;
        }

        if (!empty($m['teacher_id'])) {
            $row = DB::table('users')
                ->select(DB::raw("CONCAT(firstname, ' ', lastname) AS fullname"))
                ->where('id', $m['teacher_id'])
                ->first();
            $m['teacher_name'] = $row->fullname ?? null;
        }

        if (!empty($m['student_id'])) {
            $row = DB::table('students')
                ->select(DB::raw("CONCAT(firstname, ' ', lastname) AS fullname"))
                ->where('id', $m['student_id'])
                ->first();
            $m['student_name'] = $row->fullname ?? null;
        }

        if (!empty($m['class_section_id'])) {
            $row = DB::table('classSection')
                ->select('class_section_name')
                ->where('class_section_id', $m['class_section_id'])
                ->first();
            $m['class_section_name'] = $row->class_section_name ?? null;
        }

        return $m;
    }

    private function getTeachers(): array
    {
        $rows = $this->teacher->getTeachersAndTAs();

        return array_map(static function ($r) {
            $fullname = trim(($r['firstname'] ?? '') . ' ' . ($r['lastname'] ?? ''));
            return [
                'id' => (int) $r['id'],
                'firstname' => $r['firstname'] ?? '',
                'lastname' => $r['lastname'] ?? '',
                'fullname' => $fullname,
                'email' => $r['email'] ?? '',
                'cellphone' => $r['cellphone'] ?? '',
                'role' => $r['role'] ?? '',
            ];
        }, $rows);
    }

    private function getItems(): array
    {
        return DB::table('inventory_items')->select('id', 'name')->orderBy('name', 'ASC')->get()->toArray();
    }

    private function getClassSections(): array
    {
        return DB::table('classSection')
            ->select('class_section_id', 'class_section_name')
            ->orderBy('class_section_name', 'ASC')->get()->toArray();
    }

    private function getStudents(): array
    {
        return DB::table('students')
            ->select(DB::raw("id, CONCAT(firstname, ' ', lastname) AS fullname"))
            ->orderBy('lastname', 'ASC')
            ->orderBy('firstname', 'ASC')
            ->get()
            ->toArray();
    }
}