clqms-be/app/Controllers/Test/TestsController.php

<?php

namespace App\Controllers\Test;

use App\Controllers\BaseController;
use App\Libraries\TestValidationService;
use App\Libraries\ValueSet;
use App\Traits\ResponseTrait;

class TestsController extends BaseController
{
    use ResponseTrait;

    protected $db;
    protected $model;
    protected $modelCal;
    protected $modelGrp;
    protected $modelMap;
    protected $modelMapDetail;
    protected $modelRefNum;
    protected $modelRefTxt;
    protected $rules;

    public function __construct()
    {
        $this->db = \Config\Database::connect();
        $this->model = new \App\Models\Test\TestDefSiteModel;
        $this->modelCal = new \App\Models\Test\TestDefCalModel;
        $this->modelGrp = new \App\Models\Test\TestDefGrpModel;
        $this->modelMap = new \App\Models\Test\TestMapModel;
        $this->modelMapDetail = new \App\Models\Test\TestMapDetailModel;
        $this->modelRefNum = new \App\Models\RefRange\RefNumModel;
        $this->modelRefTxt = new \App\Models\RefRange\RefTxtModel;

        $this->rules = [
            'TestSiteCode' => 'required',
            'TestSiteName' => 'required',
            'TestType'     => 'required',
            'SiteID'       => 'required',
        ];
    }

    public function index()
    {
        $filters = [
            'SiteID' => $this->request->getGet('SiteID'),
            'TestType' => $this->request->getGet('TestType'),
            'VisibleScr' => $this->request->getGet('VisibleScr'),
            'VisibleRpt' => $this->request->getGet('VisibleRpt'),
            'TestSiteName' => $this->request->getGet('TestSiteName'),
            'TestSiteCode' => $this->request->getGet('TestSiteCode'),
        ];

        $rows = $this->model->getTestsWithRelations($filters);

        if (empty($rows)) {
            return $this->respond([
                'status'  => 'success',
                'message' => 'No data.',
                'data'    => [],
            ], 200);
        }

        $rows = ValueSet::transformLabels($rows, [
            'TestType' => 'test_type',
        ]);

        return $this->respond([
            'status'  => 'success',
            'message' => 'Data fetched successfully',
            'data'    => $rows,
        ], 200);
    }

    public function show($id = null)
    {
        if (!$id) {
            return $this->failValidationErrors('TestSiteID is required');
        }

        $row = $this->model->select('testdefsite.*')
            ->where('testdefsite.TestSiteID', $id)
            ->find($id);

        if (!$row) {
            return $this->respond([
                'status'  => 'success',
                'message' => 'No data.',
                'data'    => null,
            ], 200);
        }

        $row = ValueSet::transformLabels([$row], [
            'TestType' => 'test_type',
        ])[0];

        $typeCode = $row['TestType'] ?? '';

        if ($typeCode === 'CALC') {
            $row['testdefcal'] = $this->modelCal->getByTestSiteID($id);
        } elseif ($typeCode === 'GROUP') {
            $row['testdefgrp'] = $this->modelGrp->getGroupMembers($id);
        } elseif ($typeCode === 'TITLE') {
        } else {
            $row['testdeftech'] = $this->db->table('testdefsite')
                ->select('testdefsite.*, d.DisciplineName, dept.DepartmentName')
                ->join('discipline d', 'd.DisciplineID=testdefsite.DisciplineID', 'left')
                ->join('department dept', 'dept.DepartmentID=testdefsite.DepartmentID', 'left')
                ->where('testdefsite.TestSiteID', $id)
                ->where('testdefsite.EndDate IS NULL')
                ->get()->getResultArray();

            if (!empty($row['testdeftech'])) {
                $techData = $row['testdeftech'][0];
                $refType = $techData['RefType'];
                $resultType = $techData['ResultType'] ?? '';

                if (TestValidationService::usesRefNum($resultType, $refType)) {
                    $refnumData = $this->modelRefNum->getActiveByTestSiteID($id);

                    $row['refnum'] = array_map(function ($r) {
                        return [
                            'RefNumID'        => $r['RefNumID'],
                            'NumRefType'      => $r['NumRefType'],
                            'NumRefTypeLabel' => $r['NumRefType'] ? ValueSet::getLabel('numeric_ref_type', $r['NumRefType']) : '',
                            'RangeType'       => $r['RangeType'],
                            'RangeTypeLabel'  => $r['RangeType'] ? ValueSet::getLabel('range_type', $r['RangeType']) : '',
                            'Sex'             => $r['Sex'],
                            'SexLabel'        => $r['Sex'] ? ValueSet::getLabel('gender', $r['Sex']) : '',
                            'LowSign'         => $r['LowSign'],
                            'LowSignLabel'    => $r['LowSign'] ? ValueSet::getLabel('math_sign', $r['LowSign']) : '',
                            'HighSign'        => $r['HighSign'],
                            'HighSignLabel'   => $r['HighSign'] ? ValueSet::getLabel('math_sign', $r['HighSign']) : '',
                            'High'            => $r['High'] !== null ? (float) $r['High'] : null,
                            'Low'             => $r['Low'] !== null ? (float) $r['Low'] : null,
                            'AgeStart'        => (int) $r['AgeStart'],
                            'AgeEnd'          => (int) $r['AgeEnd'],
                            'Flag'            => $r['Flag'],
                            'Interpretation'  => $r['Interpretation'],
                        ];
                    }, $refnumData ?? []);
                }

                if (TestValidationService::usesRefTxt($resultType, $refType)) {
                    $reftxtData = $this->modelRefTxt->getActiveByTestSiteID($id);

                    $row['reftxt'] = array_map(function ($r) {
                        return [
                            'RefTxtID'       => $r['RefTxtID'],
                            'TxtRefType'     => $r['TxtRefType'],
                            'TxtRefTypeLabel'=> $r['TxtRefType'] ? ValueSet::getLabel('text_ref_type', $r['TxtRefType']) : '',
                            'Sex'            => $r['Sex'],
                            'SexLabel'       => $r['Sex'] ? ValueSet::getLabel('gender', $r['Sex']) : '',
                            'AgeStart'       => (int) $r['AgeStart'],
                            'AgeEnd'         => (int) $r['AgeEnd'],
                            'RefTxt'         => $r['RefTxt'],
                            'Flag'           => $r['Flag'],
                        ];
                    }, $reftxtData ?? []);
                }
            }
        }

        return $this->respond([
            'status'  => 'success',
            'message' => 'Data fetched successfully',
            'data'    => $row,
        ], 200);
    }

    public function create()
    {
        $input = $this->request->getJSON(true);

        if (!$this->validateData($input, $this->rules)) {
            return $this->failValidationErrors($this->validator->getErrors());
        }

        $testType = $input['TestType'] ?? '';
        $details = $input['details'] ?? $input;
        $resultType = $details['ResultType'] ?? '';
        $refType = $details['RefType'] ?? '';

        if (TestValidationService::isCalc($testType)) {
            $resultType = 'NMRIC';
            $refType = $refType ?: 'RANGE';
        } elseif (TestValidationService::isGroup($testType) || TestValidationService::isTitle($testType)) {
            $resultType = 'NORES';
            $refType = 'NOREF';
        }

        if ($resultType && $refType) {
            $validation = TestValidationService::validate($testType, $resultType, $refType);
            if (!$validation['valid']) {
                return $this->failValidationErrors(['type_validation' => $validation['error']]);
            }
        }

        $this->db->transStart();

        try {
            $testSiteData = [
                'SiteID'      => $input['SiteID'],
                'TestSiteCode'=> $input['TestSiteCode'],
                'TestSiteName'=> $input['TestSiteName'],
                'TestType'    => $input['TestType'],
                'Description' => $input['Description'] ?? null,
                'SeqScr'      => $input['SeqScr'] ?? 0,
                'SeqRpt'      => $input['SeqRpt'] ?? 0,
                'IndentLeft'  => $input['IndentLeft'] ?? 0,
                'FontStyle'   => $input['FontStyle'] ?? null,
                'VisibleScr'  => $input['VisibleScr'] ?? 1,
                'VisibleRpt'  => $input['VisibleRpt'] ?? 1,
                'CountStat'   => $input['CountStat'] ?? 1,
                'StartDate'   => $input['StartDate'] ?? date('Y-m-d H:i:s'),
            ];

            $id = $this->model->insert($testSiteData);
            if (!$id) {
                throw new \Exception('Failed to insert main test definition');
            }

            $this->handleDetails($id, $input, 'insert');

            $this->db->transComplete();

            if ($this->db->transStatus() === false) {
                return $this->failServerError('Transaction failed');
            }

            return $this->respondCreated([
                'status'  => 'created',
                'message' => 'Test created successfully',
                'data'    => ['TestSiteId' => $id],
            ]);
        } catch (\Exception $e) {
            $this->db->transRollback();

            return $this->failServerError('Something went wrong: ' . $e->getMessage());
        }
    }

    public function update($id = null)
    {
        $input = $this->request->getJSON(true);

        if (!$id && isset($input['TestSiteID'])) {
            $id = $input['TestSiteID'];
        }
        if (!$id) {
            return $this->failValidationErrors('TestSiteID is required.');
        }

        $existing = $this->model->find($id);
        if (!$existing) {
            return $this->failNotFound('Test not found');
        }

        $testType = $input['TestType'] ?? $existing['TestType'] ?? '';
        $details = $input['details'] ?? $input;
        $resultType = $details['ResultType'] ?? $existing['ResultType'] ?? '';
        $refType = $details['RefType'] ?? $existing['RefType'] ?? '';

        if (TestValidationService::isCalc($testType)) {
            $resultType = 'NMRIC';
            $refType = $refType ?: 'RANGE';
        } elseif (TestValidationService::isGroup($testType) || TestValidationService::isTitle($testType)) {
            $resultType = 'NORES';
            $refType = 'NOREF';
        }

        if ($resultType && $refType) {
            $validation = TestValidationService::validate($testType, $resultType, $refType);
            if (!$validation['valid']) {
                return $this->failValidationErrors(['type_validation' => $validation['error']]);
            }
        }

        $this->db->transStart();

        try {
            $testSiteData = [];
            $allowedUpdateFields = [
                'TestSiteCode',
                'TestSiteName',
                'TestType',
                'Description',
                'SeqScr',
                'SeqRpt',
                'IndentLeft',
                'FontStyle',
                'VisibleScr',
                'VisibleRpt',
                'CountStat',
                'StartDate',
            ];

            foreach ($allowedUpdateFields as $field) {
                if (isset($input[$field])) {
                    $testSiteData[$field] = $input[$field];
                }
            }

            if (!empty($testSiteData)) {
                $this->model->update($id, $testSiteData);
            }

            $this->handleDetails($id, $input, 'update');

            $this->db->transComplete();

            if ($this->db->transStatus() === false) {
                return $this->failServerError('Transaction failed');
            }

            return $this->respond([
                'status'  => 'success',
                'message' => 'Test updated successfully',
                'data'    => ['TestSiteId' => $id],
            ]);
        } catch (\Exception $e) {
            $this->db->transRollback();

            return $this->failServerError('Something went wrong: ' . $e->getMessage());
        }
    }

    public function delete($id = null)
    {
        $input = $this->request->getJSON(true);

        if (!$id && isset($input['TestSiteID'])) {
            $id = $input['TestSiteID'];
        }
        if (!$id) {
            return $this->failValidationErrors('TestSiteID is required.');
        }

        $existing = $this->model->find($id);
        if (!$existing) {
            return $this->failNotFound('Test not found');
        }

        if (!empty($existing['EndDate'])) {
            return $this->failValidationErrors('Test is already disabled');
        }

        $this->db->transStart();

        try {
            $now = date('Y-m-d H:i:s');

            $this->model->update($id, ['EndDate' => $now]);

            $testType = $existing['TestType'];
            $typeCode = $testType;

            if (TestValidationService::isCalc($typeCode)) {
                $this->modelCal->disableByTestSiteID($id);
            } elseif (TestValidationService::isGroup($typeCode)) {
                $this->modelGrp->disableByTestSiteID($id);
            } elseif (TestValidationService::isTechnicalTest($typeCode)) {
                $this->modelRefNum->where('TestSiteID', $id)->set('EndDate', $now)->update();
                $this->modelRefTxt->where('TestSiteID', $id)->set('EndDate', $now)->update();
            }

            $this->modelMap->disableByTestSiteID($id);

            $this->db->transComplete();

            if ($this->db->transStatus() === false) {
                return $this->failServerError('Transaction failed');
            }

            return $this->respond([
                'status'  => 'success',
                'message' => 'Test disabled successfully',
                'data'    => ['TestSiteId' => $id, 'EndDate' => $now],
            ]);
        } catch (\Exception $e) {
            $this->db->transRollback();

            return $this->failServerError('Something went wrong: ' . $e->getMessage());
        }
    }

    private function handleDetails($testSiteID, $input, $action)
    {
        $testTypeID = $input['TestType'] ?? null;

        if (!$testTypeID && $action === 'update') {
            $existing = $this->model->find($testSiteID);
            $testTypeID = $existing['TestType'] ?? null;
        }

        if (!$testTypeID) {
            return;
        }

        $typeCode = $testTypeID;

        $details = $input['details'] ?? $input;
        $details['TestSiteID'] = $testSiteID;
        $details['SiteID'] = $input['SiteID'] ?? 1;

        switch ($typeCode) {
            case 'CALC':
                $this->saveCalcDetails($testSiteID, $details, $action);

                break;

            case 'GROUP':
                $this->saveGroupDetails($testSiteID, $details, $input, $action);

                break;

            case 'TITLE':
                if (isset($input['testmap']) && is_array($input['testmap'])) {
                    $this->saveTestMap($testSiteID, $input['testmap'], $action);
                }

                break;

            case 'TEST':
            case 'PARAM':
            default:
                $this->saveTechDetails($testSiteID, $details, $action, $typeCode);

                if (in_array($typeCode, ['TEST', 'PARAM']) && isset($details['RefType'])) {
                    $refType = (string) $details['RefType'];
                    $resultType = $details['ResultType'] ?? '';

                    if (TestValidationService::usesRefNum($resultType, $refType) && isset($input['refnum']) && is_array($input['refnum'])) {
                        $this->saveRefNumRanges($testSiteID, $input['refnum'], $action, $input['SiteID'] ?? 1);
                    }

                    if (TestValidationService::usesRefTxt($resultType, $refType) && isset($input['reftxt']) && is_array($input['reftxt'])) {
                        $this->saveRefTxtRanges($testSiteID, $input['reftxt'], $action, $input['SiteID'] ?? 1);
                    }
                }

                break;
        }

        if ((TestValidationService::isTechnicalTest($typeCode) || TestValidationService::isCalc($typeCode)) && isset($input['testmap']) && is_array($input['testmap'])) {
            $this->saveTestMap($testSiteID, $input['testmap'], $action);
        }
    }

    private function saveTechDetails($testSiteID, $data, $action, $typeCode)
    {
        $techData = [
            'DisciplineID'   => $data['DisciplineID'] ?? null,
            'DepartmentID'   => $data['DepartmentID'] ?? null,
            'ResultType'     => $data['ResultType'] ?? null,
            'RefType'        => $data['RefType'] ?? null,
            'VSet'           => $data['VSet'] ?? null,
            'ReqQty'         => $data['ReqQty'] ?? null,
            'ReqQtyUnit'     => $data['ReqQtyUnit'] ?? null,
            'Unit1'          => $data['Unit1'] ?? null,
            'Factor'         => $data['Factor'] ?? null,
            'Unit2'          => $data['Unit2'] ?? null,
            'Decimal'        => $data['Decimal'] ?? 2,
            'CollReq'        => $data['CollReq'] ?? null,
            'Method'         => $data['Method'] ?? null,
            'ExpectedTAT'    => $data['ExpectedTAT'] ?? null,
        ];

        $this->model->update($testSiteID, $techData);
    }

    private function saveRefNumRanges($testSiteID, $ranges, $action, $siteID)
    {
        if ($action === 'update') {
            $this->modelRefNum->where('TestSiteID', $testSiteID)
                ->set('EndDate', date('Y-m-d H:i:s'))
                ->update();
        }

        foreach ($ranges as $index => $range) {
            $this->modelRefNum->insert([
                'TestSiteID'   => $testSiteID,
                'SiteID'       => $siteID,
                'NumRefType'   => $range['NumRefType'],
                'RangeType'    => $range['RangeType'],
                'Sex'          => $range['Sex'],
                'AgeStart'     => (int) ($range['AgeStart'] ?? 0),
                'AgeEnd'       => (int) ($range['AgeEnd'] ?? 150),
                'LowSign'      => !empty($range['LowSign']) ? $range['LowSign'] : null,
                'Low'          => !empty($range['Low']) ? (float) $range['Low'] : null,
                'HighSign'     => !empty($range['HighSign']) ? $range['HighSign'] : null,
                'High'         => !empty($range['High']) ? (float) $range['High'] : null,
                'Flag'         => $range['Flag'] ?? null,
                'Interpretation'=> $range['Interpretation'] ?? null,
                'Display'      => $index,
                'CreateDate'   => date('Y-m-d H:i:s'),
            ]);
        }
    }

    private function saveRefTxtRanges($testSiteID, $ranges, $action, $siteID)
    {
        if ($action === 'update') {
            $this->modelRefTxt->where('TestSiteID', $testSiteID)
                ->set('EndDate', date('Y-m-d H:i:s'))
                ->update();
        }

        foreach ($ranges as $range) {
            $this->modelRefTxt->insert([
                'TestSiteID' => $testSiteID,
                'SiteID'     => $siteID,
                'TxtRefType' => $range['TxtRefType'],
                'Sex'        => $range['Sex'],
                'AgeStart'   => (int) ($range['AgeStart'] ?? 0),
                'AgeEnd'     => (int) ($range['AgeEnd'] ?? 150),
                'RefTxt'     => $range['RefTxt'] ?? '',
                'Flag'       => $range['Flag'] ?? null,
                'CreateDate' => date('Y-m-d H:i:s'),
            ]);
        }
    }

    private function saveCalcDetails($testSiteID, $data, $action)
    {
        $calcData = [
            'TestSiteID'    => $testSiteID,
            'DisciplineID'  => $data['DisciplineID'] ?? null,
            'DepartmentID'  => $data['DepartmentID'] ?? null,
            'FormulaInput'  => $data['FormulaInput'] ?? null,
            'FormulaCode'   => $data['FormulaCode'] ?? $data['Formula'] ?? null,
            'ResultType'    => 'NMRIC',
            'RefType'       => $data['RefType'] ?? 'RANGE',
            'Unit1'         => $data['Unit1'] ?? $data['ResultUnit'] ?? null,
            'Factor'        => $data['Factor'] ?? null,
            'Unit2'         => $data['Unit2'] ?? null,
            'Decimal'       => $data['Decimal'] ?? 2,
            'Method'        => $data['Method'] ?? null,
        ];

        if ($action === 'update') {
            $exists = $this->modelCal->existsByTestSiteID($testSiteID);

            if ($exists) {
                $this->modelCal->update($exists['TestCalID'], $calcData);
            } else {
                $this->modelCal->insert($calcData);
            }
        } else {
            $this->modelCal->insert($calcData);
        }
    }

    private function saveGroupDetails($testSiteID, $data, $input, $action)
    {
        if ($action === 'update') {
            $this->modelGrp->disableByTestSiteID($testSiteID);
        }

        $members = $data['members'] ?? ($input['Members'] ?? []);

        if (is_array($members)) {
            foreach ($members as $m) {
                $memberID = is_array($m) ? ($m['Member'] ?? ($m['TestSiteID'] ?? null)) : $m;
                if ($memberID) {
                    $this->modelGrp->insert([
                        'TestSiteID' => $testSiteID,
                        'Member'     => $memberID,
                    ]);
                }
            }
        }
    }

    private function saveTestMap($testSiteID, $mappings, $action)
    {
        if ($action === 'update') {
            $existingMaps = $this->modelMap->where('TestSiteID', $testSiteID)
                ->where('EndDate', null)
                ->findAll();

            foreach ($existingMaps as $existingMap) {
                $this->modelMapDetail->where('TestMapID', $existingMap['TestMapID'])
                    ->where('EndDate', null)
                    ->set('EndDate', date('Y-m-d H:i:s'))
                    ->update();
            }

            $this->modelMap->disableByTestSiteID($testSiteID);
        }

        if (is_array($mappings)) {
            foreach ($mappings as $map) {
                $mapData = [
                    'TestSiteID' => $testSiteID,
                    'HostType'   => $map['HostType'] ?? null,
                    'HostID'     => $map['HostID'] ?? null,
                    'ClientType' => $map['ClientType'] ?? null,
                    'ClientID'   => $map['ClientID'] ?? null,
                ];
                $testMapID = $this->modelMap->insert($mapData);

                if ($testMapID && isset($map['details']) && is_array($map['details'])) {
                    foreach ($map['details'] as $detail) {
                        $detailData = [
                            'TestMapID'      => $testMapID,
                            'HostTestCode'   => $detail['HostTestCode'] ?? null,
                            'HostTestName'   => $detail['HostTestName'] ?? null,
                            'ConDefID'       => $detail['ConDefID'] ?? null,
                            'ClientTestCode' => $detail['ClientTestCode'] ?? null,
                            'ClientTestName' => $detail['ClientTestName'] ?? null,
                        ];
                        $this->modelMapDetail->insert($detailData);
                    }
                }
            }
        }
    }
}