ria/app/Controllers/StockController.php

<?php

namespace App\Controllers;

use App\Controllers\BaseController;
use App\Models\Supplier_model;
use App\Models\PowerConsumptionDetails;
use App\Models\CoatingMachineDetailsModel;
use App\Models\DrierMachineDetailsModel;
use App\Models\FactoryMachineModel;
use App\Models\FactoryVehicleDieselDetailsModel;
use App\Models\FactoryVehicleDieselStockSummaryModel;
use App\Models\IncomingSilicaSandDetailsModel;
use App\Models\Inwardgateregister_model;
use App\Models\Rawmaterialdetails_model;
use App\Models\BagStockDetailsModel;
use App\Models\DustAndRoughModel;
use App\Models\ResinStockModel;
use App\Models\GasStockModel;
use App\Models\TrpAbstract;
use App\Models\TrpAbstractParticulars;
use App\Models\TrpSandUseStockModel;
use App\Models\TrpProductionModel;
use App\Models\TrpProductionMaintenanceModel;
use App\Models\TrpProductionWasteModel;
use App\Models\Employeedetails_model;
use App\Models\PowerConsumptionSummaryModel;





use CodeIgniter\HTTP\ResponseInterface;
use DateTime;
use DatePeriod;
use DateInterval;

class StockController extends BaseController
{

    protected $supplier_model;
    protected $powerConsumptionDetails_model;
    protected $powerConsumptionSummary_model;
    protected $coatingMachineDetails_model;
    protected $drierMachineDetails_model;
    protected $factoryMachine_model;
    protected $factoryVehicleDieselDetails_model;
    protected $factoryVehicleDieselStockSummary_model;
    protected $session;
    protected $incomingSilicaSandDetails_model;
    protected $inwardGateRegister_model;
    protected $rawmaterialdetails_model;
    protected $bagStockDetails_model;
    protected $Rawmaterialdetails_model;
    protected $dustAndRoughStockDetails_model;
    protected $resinStockDetails_model;
    protected $gasStockDetails_model;

    protected $TrpSandUseStock_model;

    protected $TrpProduction_model;

    protected $TrpProductionMaintenance_model;

    protected $TrpProductionWaste_model;

    protected $db;

    protected $employeedetails_model;

    protected $trpAbstractParticularsModel ;

    protected $trpAbstractModel ;


    /**
     * This is default constructor of the class
     */
    public function __construct()
    {
        $this->db = \Config\Database::connect();
        parent::__construct();

        $this->supplier_model = new Supplier_model();

        $this->powerConsumptionDetails_model = new PowerConsumptionDetails();

        $this->coatingMachineDetails_model = new CoatingMachineDetailsModel();

        $this->drierMachineDetails_model = new DrierMachineDetailsModel();

        $this->factoryMachine_model = new FactoryMachineModel();

        $this->factoryVehicleDieselDetails_model = new FactoryVehicleDieselDetailsModel();

        $this->factoryVehicleDieselStockSummary_model = new FactoryVehicleDieselStockSummaryModel();

        $this->rawmaterialdetails_model = new Rawmaterialdetails_model();

        $this->incomingSilicaSandDetails_model = new IncomingSilicaSandDetailsModel();

        $this->inwardGateRegister_model = new Inwardgateregister_model();

        $this->bagStockDetails_model = new BagStockDetailsModel();

        $this->dustAndRoughStockDetails_model = new DustAndRoughModel();

        $this->resinStockDetails_model = new ResinStockModel();

        $this->gasStockDetails_model = new GasStockModel();

        $this->TrpSandUseStock_model = new TrpSandUseStockModel();

        $this->TrpProduction_model = new TrpProductionModel();

        $this->TrpProductionMaintenance_model = new TrpProductionMaintenanceModel();

        $this->TrpProductionWaste_model = new TrpProductionWasteModel();

        $this->employeedetails_model = new Employeedetails_model();

        $this->powerConsumptionSummary_model = new PowerConsumptionSummaryModel();

        $this->trpAbstractParticularsModel   = new TrpAbstractParticulars();

        $this->trpAbstractModel              = new TrpAbstract();


        $this->session = session();
        helper('form');

        $this->isLoggedIn();
    }

    public function index()
    {
        //
    }

    //Coating Machine Details  starts
    public function loadView_coatingMachineDetails()
    {

        if ($this->request->getMethod() === 'POST') {
            
            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;  
            
            $session = session ();

            $session->set('stock_month',$month);

        } else {

            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }

        }

        $data['month'] = $month ;

        $this->global['pageTitle'] = 'Coating Machine Details ';


        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));
        $data['coatingMachineDetails'] = $this->coatingMachineDetails_model
                    ->select('t_coatingMachineDetails.*, 
                            JSON_ARRAYAGG(
                                JSON_OBJECT(
                                "client_given_name", t_batchcard_files.client_file_name, 
                                "filename", t_batchcard_files.filename,
                                "batchCardId" , t_batchcard_files.id,
                                "coating_id", t_batchcard_files.coating_id
                                )
                            ) as batchcard_files') 
                    ->join('t_batchcard_files', 't_batchcard_files.coating_id = t_coatingMachineDetails.id', 'left')
                    ->where('t_coatingMachineDetails.date >=', $startDate)
                    ->where('t_coatingMachineDetails.date <=', $endDate)
                    ->groupBy('t_coatingMachineDetails.id')
                    ->orderBy('t_coatingMachineDetails.date', 'asc')
                    ->findAll();
          

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        return $this->loadViews("stock/CoatingMachineDetail", $this->global, $data, NULL);
    }

    public function addNewCoatingMachineDetails()
    {
        $message1 = '';
        $message2 = '';
        $message3 = '';

        $postData = $this->request->getPost();

        $date = $postData['date'];
        $shift = $postData['shift'];

        // Check if the same shift already exists on the same date  
        $sameShiftOnDateExists = $this->coatingMachineDetails_model
            ->where('date', $date)
            ->where('shift', $shift)
            ->where('is_active', 1) 
            ->first();  

        if (!empty($sameShiftOnDateExists)) {
            return redirect()->back()->with('error', 'Already same shift exists on the same date ..!!');
        }

        // Start transaction
        $this->db->transBegin();

        try {
            // Insert into coating machine details table
            $insertedId = $this->coatingMachineDetails_model->insert($postData);

            if ($insertedId !== false && $insertedId > 0) {

                $message1 = 'Coating Machine details updated successfully';

                // Update gas stock consumption
                $dateToBeInserted = $postData['date'];
                $consumption = $postData['totalGasConsumption'];
                $updatedResult = $this->updateGasStockConsumption($dateToBeInserted, $consumption);

                if ($updatedResult === false || $updatedResult <= 0) {
                    // Explicit failure handling for gas stock update
                    throw new \Exception('Failed to update gas stock consumption.');
                }
                $message2 = 'And updated gas stock consumption.';
                $message3 = " Warning..!! Kindly Update the next subsequent month Gas Stock If older month Gas Stock Updated..!!";
            } else {
                throw new \Exception('Failed to insert Coating machine details.');
            }

            if ($insertedId !== false && $insertedId > 0) {

                $batchCardFiles = $this->request->getFileMultiple('batchCard');

                if (!empty($batchCardFiles) && !($batchCardFiles[0]->getError() === UPLOAD_ERR_NO_FILE)) {
        
                    foreach ($batchCardFiles as $file) {
        
                        if ($file->isValid() && !$file->hasMoved()) {
                            $clientGivenName = $file->getClientName(); // User-given filename
                            $newName = $file->getRandomName();
                            
                            if ($file->move(WRITEPATH . 'uploads/batchcard', $newName)) {
                                // Only save to DB if file moved successfully   
                                $db = \Config\Database::connect();
                                $builder = $db->table('t_batchcard_files');
                
                                $data = [
                                    'client_file_name' => $clientGivenName, 
                                    'filename' => $newName,     
                                    'coating_id' => $insertedId
                                ];
                
                                $builder->insert($data);
                            }
                        }
                    }
                }

            }



            if ($this->db->transStatus() === false) {
                throw new \Exception('Transaction failed due to database errors.');
            }
            $this->db->transCommit();



            // Set flashdata for success message
            return redirect()->to("/coatingMachineDetails")
                ->with('success', $message1 . " " . $message2 . " " . $message3);
        } catch (\Exception $error) {
            $this->db->transRollback();
            return redirect()->back()->with('error', ' ' . $error->getMessage());
        }
    }



    public function updateCoatingMachineDetails()
    {

       
        $message1 = '';
        $message2 = '';
        $message3 = '';

        $putData = $this->request->getPost();


        $id = $putData['editCoatingMachineDetailId'];

        // Start transaction
        $this->db->transBegin();
        try {
            $updated = $this->coatingMachineDetails_model->update($id, $putData);

          

            if ($updated !== false && $updated > 0) { // Assuming $id is the record ID being updated

                $batchCardFiles = $this->request->getFileMultiple('batchCard');

                    
                    // Step 4: Upload new files and insert into DB
                    foreach ($batchCardFiles as $index => $file) {  
                        
                        if ( !empty($batchCardFiles[$index]) && !($batchCardFiles[$index]->getError() === UPLOAD_ERR_NO_FILE)) {
                    
                            $db = \Config\Database::connect();
                            $builder = $db->table('t_batchcard_files'); 

                        if ($file->isValid() && !$file->hasMoved()) {
                            $clientGivenName = $file->getClientName(); // User-given filename
                            $newName = $file->getRandomName(); // Randomized unique filename
                            
                            // Move the new file to storage
                            if ($file->move(WRITEPATH . 'uploads/batchcard', $newName)) {
                                // Insert new file record into the database
                                $data = [
                                    'client_file_name' => $clientGivenName, 
                                    'filename' => $newName,     
                                    'coating_id' => $id
                                ];
                                $builder->insert($data);
                            }
                        }
                    }
                }
            }
            
            if ($updated !== false && $updated > 0) {
                $message1 = "successfully updated Coating machineDetail .";
                //update Gas stock consumption if update is successfull..!!
                $dateToBeUpdated = $putData['date'];

                $existingCoatingGasConsumption = $putData['existingTotalGasConsumption'];
                $updatedCoatingGasConsumption =  $putData['totalGasConsumption'];   

                if ($existingCoatingGasConsumption != $updatedCoatingGasConsumption) {

                    $changeInConsumption = $updatedCoatingGasConsumption - $existingCoatingGasConsumption;
                    $updatedResult = $this->updateGasStockConsumption($dateToBeUpdated, $changeInConsumption);

                    if ($updatedResult === false || $updatedResult <= 0) {
                        // Explicit failure handling for gas stock update
                        throw new \Exception('Failed to update gas stock consumption.');
                    }
                    $message2 = 'And updated gas stock consumption.';

                    $message3 = "Warning..!! Kindly Update the next subsequent month Gas Stock If older month Gas Stock Updated..!!";
                }
                // Commit the transaction if all queries succeed


                if ($this->db->transStatus() === false) {
                    throw new \Exception('Transaction failed due to database errors.');
                }
                $this->db->transCommit();




                // Set flashdata for success message
                return redirect()->to("/coatingMachineDetails")
                    ->with('success', $message1 . " " . $message2 . " " . $message3);
            } else {
                throw new \Exception('Failed to update Coating machine details.');
            }
            
            
            


        } catch (\Exception $error) {
            $this->db->transRollback();
            return redirect()->back()->with('error', ' ' . $error->getMessage());
        }
    }

    public function deleteBatchCardFile()
    {
        $data = $this->request->getPost();
    
        if (!empty($data)) {
            
            $batchId = $data['id'];
            $db = \Config\Database::connect();
            $builder = $db->table('t_batchcard_files');
    
            // Step 1: Fetch the filename from DB before deleting
            $fileRecord = $builder->select('filename')->where('id', $batchId)->get()->getRow();
    
            if ($fileRecord) {
                $filePath = WRITEPATH . 'uploads/batchcard/' . $fileRecord->filename;
    
                // Step 2: Delete the file from storage
                if (file_exists($filePath)) {
                    unlink($filePath);
                }
    
                // Step 3: Delete the record from the database
                $sql = "DELETE FROM t_batchcard_files WHERE id = ?";
                $deleted = $db->query($sql, [$batchId]);
    
                if ($deleted) {
                    return $this->response->setJSON([
                        'status'  => '200',
                        'message' => "Deleted Batch Card File Successfully..!!"
                    ]);
                } else {
                    return $this->response->setJSON([
                        'status'  => '400',
                        'message' => "Failed to Delete..!! Try Again Later"
                    ]);
                }
            } else {
                return $this->response->setJSON([
                    'status'  => '404',
                    'message' => "File Not Found..!!"
                ]);
            }
        }
    
        return $this->response->setJSON([
            'status'  => '400',
            'message' => "Invalid Request..!!"
        ]);
    }


    public function downloadBatchcardZip()
    {
        $coatingId = $this->request->getGet('coating_id'); 
        $date      = $this->request->getGet('date');
        $batchCardFiles = $this->getBatchCardFiles($coatingId); // Fetch files from DB
    
        if (empty($batchCardFiles)) {
            return redirect()->back()->with('error', 'No batchcard files found.');
        }
    
        $zipFileName = 'batchcard_files_' . $date . '.zip'; 
        $zipFilePath = WRITEPATH . 'uploads/batchcard' . $zipFileName; // CI4 WRITEPATH safe directory
    
        $zip = new \ZipArchive();
        if ($zip->open($zipFilePath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) === true) {
            foreach ($batchCardFiles as $file) {
                $originalFilePath = WRITEPATH . 'uploads/batchcard/' . $file['filename']; // Actual stored file
                $clientFileName = $file['client_file_name'] ?? $file['filename']; // Use client name if available
                
                if (file_exists($originalFilePath)) {
                    $zip->addFile($originalFilePath, $clientFileName); // Rename inside ZIP
                }
            }
            $zip->close();
    
            $response = $this->response->download($zipFilePath, null)->setFileName($zipFileName);

            // Delete ZIP after response is sent
            register_shutdown_function(function () use ($zipFilePath) {
                if (file_exists($zipFilePath)) {
                    unlink($zipFilePath);
                }
            });
    
            return $response;
        }
    
        return redirect()->back()->with('error', 'Failed to create ZIP file.');
    }
    
    // Example function to get batchcard files from DB
    private function getBatchCardFiles($coatingId)
    {
        $batchCardFiles = $this->db->table('t_batchcard_files')
            ->where('coating_id', $coatingId)
            ->get()
            ->getResultArray();
    
        return $batchCardFiles;
    }
    
    

    //incoming Silica Sand Details  starts
    public function loadView_incomingSilicaSandDetails()
    {

        if ($this->request->getMethod() === 'POST') {

            $remark = $this->request->getPost('remark');

            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);


        } else {
            $remark = $this->request->getVar('remark');

            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }

        }

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Incoming Silica Sand Details';

        $materialCodes = [];

        $silicaSandMaterialCodes = $this->rawmaterialdetails_model->getAllSilicaRawMaterialCode();

        $materialCodes [] = $silicaSandMaterialCodes;

        $wasteCoreSandMaterialCodes = $this->rawmaterialdetails_model->getAllWasteCoreSandMaterialCode();

        $materialCodes [] = $wasteCoreSandMaterialCodes;

        $materialCodes = call_user_func_array('array_merge', $materialCodes);


        if (!empty($materialCodes)) {
            $data['igrDetails'] = $this->inwardGateRegister_model->findIgrDetailsForIncomingSilicaSand($materialCodes, $month, $remark);
        } else {
            $data['igrDetails'] = [];
        }

        $data['testedBy'] = [];

        $DesignationConfigID = 'C010';

        $data['testedBy'] = $this->employeedetails_model->incomingSilicaSandTestedBy($DesignationConfigID);

        $data['approvedBy'] = $this->employeedetails_model->incomingSilicaSandApprovedBy($DesignationConfigID);


        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        $data['remark'] = $remark;

        return $this->loadViews("stock/incomingSilicaSandDetails", $this->global, $data, NULL);
    }

    public function updateIncomingSilicaSandDetails()
    {

        $postData = $this->request->getPost();

        $incomingSilicaSandDetailsData = json_decode($postData['incomingSilicaSandDetailsData'], true);

        $inserts = [];
        $updates = [];

        foreach ($incomingSilicaSandDetailsData as $data) {

            $id = $data['id'];

            $dbData = [
                'igrNo_fk' => $data['IGR No'],
                'materialCode' => $data['MaterialCode'],
                'grade' => $data['Grade'],
                'gradeCondition' => $data['Grade Condition'],
                '_10' => $data['___10___'],
                '_20' => $data['___20___'],
                '_30' => $data['___30___'],
                '_40' => $data['___40___'],
                '_50' => $data['___50___'],
                '_70' => $data['___70___'],
                '_100' => $data['___100___'],
                '_140' => $data['___140___'],
                '_200' => $data['___200___'],
                '_300' => $data['___300___'],
                'pan' => $data['PAN'],
                'total' => $data['Total'],
                'afsSpec' => $data['AFS Spec'],
                'afsActual' => $data['AFS Actual'],
                'plus20loss' => $data['Plus 20 loss%'],
                'plus30Loss' => $data['Plus 30 Loss %'],
                'moistureSpec' => $data['Moisture % Spec'],
                'moistureActual' => $data['Moisture Actual'],
                'moistureLoss' => $data['Moisture Loss'],
                'moistureLossQty' => $data['Moisture loss Qty'],
                'sieveLossQty' => $data['Sieve Loss Qty'],
                'salableQty' => $data['Salable Qty'],
                'remark' => $data['Remark']

            ];



            $resultExists = $this->incomingSilicaSandDetails_model
                ->where('id', $id)
                ->first();

            if (!empty($resultExists)) {
                $dbData['id'] = $resultExists['id'];
                $updates[] = $dbData;
            } else {
                $inserts[] = $dbData;
            }
        }

        if (!empty($updates)) {
            $updated = $this->incomingSilicaSandDetails_model->updateBatch($updates, 'id');
        }

        if (!empty($inserts)) {
            $inserted = $this->incomingSilicaSandDetails_model->insertBatch($inserts);
        }

        echo "Data Saved Successfully";
    }

    public function updateLabReport()
    {

        $postData = $this->request->getPost();

        $id = $postData['id'];

        $dbData = [
            'igrNo_fk'     => $postData['igrNo'],
            'materialCode' => $postData['materialCode'],
            '_10' => $postData['_10Mm'],
            '_20' => $postData['_20Mm'],
            '_30' => $postData['_30Mm'],
            '_40' => $postData['_40Mm'],
            '_50' => $postData['_50Mm'],
            '_70' => $postData['_70Mm'],
            '_100' => $postData['_100Mm'],
            '_140' => $postData['_140Mm'],
            '_200' => $postData['_200Mm'],
            '_300' => $postData['_300Mm'],
            'pan'  => $postData['pan'],
            'total'          => $postData['total'],
            'plus20Loss'     => $postData['plus20Loss'],
            'plus30Loss'     => $postData['plus30Loss'],
            'moistureSpec'   => $postData['moistureSpec'],
            'moistureActual' => $postData['moistureActual'],
            'moistureLoss'   => $postData['moistureLoss'],
            'moistureLossQty' => $postData['moistureLossQty'],
            'sieveLossQty'   => $postData['sieveLossQty'],
            'salableQty'     => $postData['salableQty'],
            'testedBy' => $postData['testedBy'],
            'approvedBy' => $postData['approvedBy'],
            'clayOrLossOfIgnition' => $postData['clayOrLossOfIgnition'],
            'reportComments'  => $postData['reportComments'],
            'gradeRange'      => $postData['gradeRange'],
            'reportTime'      => $postData['reportTime']

        ];

       

        $resultExists = $this->incomingSilicaSandDetails_model
            ->where('id', $id)
            ->first();
        if ($resultExists) {
            $updated = $this->incomingSilicaSandDetails_model
                ->update($id, $dbData);
        } else {
            $updated = $this->incomingSilicaSandDetails_model
                ->insert($dbData);
            }  


        if ($updated) {
            return $this->response->setJSON(['status' => 'success', 'message' => 'Data Updated Successfully']);
        } else {
            return $this->response->setJSON(['status' => 'error', 'message' => 'Failed to update data']);
        }
    }


    // Bag Stock details starts


    //custom filterMaterialCode given by user

    //two types of custom filter

    //1) fliter for no data present in db - active and is active is not a concern ..!!(for current month)
    //   +  adding new material in packing material category is not a concern ..!!
    //   -  deleting existing material in packing material category is not a concern ..!!

    //fetch all active material in bag stock then ,
        // i) if no custom filter option given , all active material code going to be present in filterMaterialCode .
        // ii)if    custom filter option given , what are all the materials active is going to be filtered among given filterMaterialCode.. 


        //----------------1st part finished----//


    //2) filter for data present in db -- active and is active is a concern ..!!
    //  + adding new material category in packing material is a concern ..!!
    //  - deleting existing material category in packing material is a concern ..!!

    //for second case if already material present in db but deleted in material master means 
        // i) we need to show the deleted one too for that month .
        // ii)check If they add another material in packing material for current month, 
        // we need to put dummy entry(empty string) and show that as well.

    //wild scenario if user wants to add an new material and its entry in previous month 
       //i) Hard code database entry after consultation can be entertained..!!

       //-------------- 2nd part finished -----//


    // Action 







    public function loadView_bagStockDetails()
    {

        if ($this->request->getMethod() === 'POST') {
            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate; 

            $session = session ();

            $session->set('stock_month',$month);


        } else {

            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Bag Stock Details';


        // Get the previous month's last date bag stock details for next month updation

        $previousMonth = DateTime::createFromFormat('Y-m', $month)->modify('-1 month')->format('Y-m');
        $previousMonthStartDate = "$previousMonth-01";
        $previousMonthEndDate = date("Y-m-t", strtotime($previousMonthStartDate));
        $data['previousMonthBagStockDetails'] = $this->bagStockDetails_model
            ->select(['materialCode', 'date', 'balanceStock'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)
            ->groupBy(['materialCode', 'date'])
            ->orderBy('date', 'desc')
            ->orderBy('materialCode', 'asc')
            ->findAll();



         // checking in database if the data is available for the month

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));
        $data['bagStockDetails'] = $this->bagStockDetails_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->groupBy(['materialCode', 'date'])
            ->orderBy('date', 'asc')
            ->orderBy('materialCode', 'asc')
            ->findAll();

        // Initialize an empty array to hold the grouped data
        $data['groupedBagStockDetails'] = [];

        // Temporary array to store grouped data by date
        $groupedByDate = [];

        // Group by 'date'
        foreach ($data['bagStockDetails'] as $detail) {
            $date = $detail['date'];

            // Initialize the array for this date if it doesn't exist
            if (!isset($groupedByDate[$date])) {
                $groupedByDate[$date] = [];
            }


            /*******************************************************************************************************************
             creating an sub array (inner array) for date wise and append the detail into an array as sub-array 

             $groupedByDate[] outer array

             $groupedByDate[$date]
             will look like [[bag1],[bag2],[bag3],[bag4],[bag5]] inner array

             the above process is done for single row (date wise) and the same process is repeated for all the rows
            *******************************************************************************************************************/


            // Append the detail to the sub-array for this date
            $groupedByDate[$date][] = $detail;
        }

        // Reset the structure to have indexed arrays without the date keys
        $data['groupedBagStockDetails'] = array_values($groupedByDate);




        // getting bag material for creating table headers
        // checking already existing  stock if yes then get the material code from the existing bag
        // if not get all the material codes from the raw material details table

        if (!empty($data['groupedBagStockDetails'])) {
            $result = $groupedByDate[$date];

            $distinctMaterialCodes = [];

            foreach ($result as $index => $eachResult) {
                $distinctMaterialCodes[] = $result[$index]['materialCode'];
            }

            $bagMaterials = $this->rawmaterialdetails_model->getSelectedBagMaterialCode($distinctMaterialCodes);
      
        } else {
            $bagMaterials = $this->rawmaterialdetails_model->getAllBagMaterialCode();
        }

        
        // getting customer for creating table headers
        // checking already existing  stock if yes then get customer from the existing stock
        // if not set customer as '' empty string
        
        foreach ($bagMaterials as $key => $bagMaterial) {
            $materialCode = $bagMaterial['MaterialCode'];
            $bagMaterials[$key]['customers'] = $this->bagStockDetails_model
                ->select('customer')
                ->where('date >=', $startDate)
                ->where('date <=', $endDate)
                ->where('materialCode', $materialCode)
                ->first()['customer'] ?? '';
        }

        $bagMaterialcount = count($bagMaterials);

        $data['bagMaterialcount'] = $bagMaterialcount;
        $data['bagMaterials'] = $bagMaterials;

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        return $this->loadViews("stock/bagStockDetails", $this->global, $data, NULL);
    }

    public function updateBagStockDetails()
    {

        $postData = $this->request->getPost();

        $updateBagStockDetailsData = json_decode($postData['updateBagStockDetails'], true);

        $inserts = [];
        $updates = [];

        foreach ($updateBagStockDetailsData as $data) {

            $date = $data['date'];
            $materialCode = $data['materialCode'];


            $dbData = [
                'date' => $data['date'],
                'materialCode' => $data['materialCode'],
                'customer' => $data['customer'],
                'opening' => $data['opening'],
                'receipt' => $data['receipt'],
                'used' => $data['used'],
                'balanceStock' => $data['balanceStock'],
            ];

            $resultExists = $this->bagStockDetails_model
                ->where('date', $date)
                ->where('materialCode', $materialCode)
                ->first();


            if (empty($resultExists)) {
                $inserts[] = $dbData;
            } else {
                $dbData['id'] = $resultExists['id'];
                $updates[] = $dbData;
            }
        }

        if (!empty($inserts)) {
            $inserted = $this->bagStockDetails_model->insertBatch($inserts);
        }
        if (!empty($updates)) {

            $updateResult = $this->bagStockDetails_model->updateBatch($updates, 'id');

            if ($updateResult === FALSE) {
                echo "Error during update";
            } else {
                echo "Data Updated Successfully";
                return;
            }
        }

        echo "Data Saved Successfully";
    }


    //Dust And Rough Stock Details
    public function loadView_dustAndRoughStockDetails()
    {

        if ($this->request->getMethod() === 'POST') {
            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);

        } else {
            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Dust And Rough Stock Details';

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));
        $data['dustAndRoughStockDetails'] = $this->dustAndRoughStockDetails_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->orderBy('date', 'asc')
            ->findAll();

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        return $this->loadViews("stock/dustAndRoughStockDetails", $this->global, $data, NULL);
    }

    public function updateDustAndRoughStockDetails()
    {

        $postData = $this->request->getPost();

        $updateDustAndRoughStockDetailsData = json_decode($postData['updateDustAndRoughStockDetails'], true);

        $updates = [];

        $inserts = [];

        foreach ($updateDustAndRoughStockDetailsData as $data) {

            $data['date'] = DateTime::createFromFormat('d-m-Y', $data['date'])->format('Y-m-d');

            $date = $data['date'];

            $dbData = [
                'date' => $data['date'],
                'finalRough' => $data['finalRough'],
                'dust' => $data['dust'],
                'total' => $data['total']
            ];

            $resultExists = $this->dustAndRoughStockDetails_model
                ->where('date', $date)
                ->first();


            if (empty($resultExists)) {
                $inserts[] = $dbData;
            } else {
                $updates[] = $dbData;
            }
        }

        if (!empty($inserts)) {
            $this->dustAndRoughStockDetails_model->insertBatch($inserts);
        }

        if (!empty($updates)) {

            $updateResult = $this->dustAndRoughStockDetails_model->updateBatch($updates, 'date');

            if ($updateResult === FALSE) {
                echo "Error during update";
            } else {
                echo "Data Updated Successfully";
                return;
            }
        }

        echo "Data Saved Successfully";
    }


    //Resin Stock Details
    public function loadView_resinStockDetails()
    {

        if ($this->request->getMethod() === 'POST') {

            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);

        } else {
            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Resin Stock Details';


        // Get the previous month's last date resin stock details for next month updation

        $previousMonth = DateTime::createFromFormat('Y-m', $month)->modify('-1 month')->format('Y-m');
        $previousMonthStartDate = "$previousMonth-01";
        $previousMonthEndDate = date("Y-m-t", strtotime($previousMonthStartDate));
        $data['previousMonthResinStockDetails'] = $this->resinStockDetails_model
            ->select(['materialCode', 'date', 'balanceStock'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)
            ->groupBy(['materialCode', 'date'])
            ->orderBy('date', 'desc')
            ->orderBy('materialCode', 'asc')
            ->findAll();



        // checking in database if the data is available for the month

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));
        $data['resinStockDetails'] = $this->resinStockDetails_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->groupBy(['materialCode', 'date'])
            ->orderBy('date', 'asc')
            ->orderBy('materialCode', 'asc')
            ->findAll();

        // Initialize an empty array to hold the grouped data
        $data['groupedResinStockDetails'] = [];

        // Temporary array to store grouped data by date
        $groupedByDate = [];

        // Group by 'date'
        foreach ($data['resinStockDetails'] as $detail) {
            $date = $detail['date'];

            // Initialize the outer array for this date if it doesn't exist
            if (!isset($groupedByDate[$date])) {
                $groupedByDate[$date] = [];
            }

            /*******************************************************************************************************************
             creating an sub array (inner array) for date wise and append the detail into an array as sub-array 

             $groupedByDate[] outer array

             $groupedByDate[$date]
             will look like [[material1],[material2],[material3],[material4],[material5]] inner array

             the above process is done for single row (date wise) and the same process is repeated for all the rows
            *******************************************************************************************************************/

            $groupedByDate[$date][] = $detail;
        }

        // Reset the structure to have indexed arrays without the date keys
        $data['groupedResinStockDetails'] = array_values($groupedByDate);



        // getting resin material for creating table headers
        // checking already existing  stock if yes then get the material code from the existing stock
        // if not get all the material codes from the raw material details table

        if (!empty($data['groupedResinStockDetails'])) {
           
            $result = $groupedByDate[$date];

            $distinctMaterialCodes = [];

            foreach ($result as $index => $eachResult) {
                $distinctMaterialCodes[] = $result[$index]['materialCode'];
            }

            $resinMaterials = $this->rawmaterialdetails_model->getSelectedResinMaterialCode($distinctMaterialCodes);
      
        } else {
           
            $resinMaterials = $this->rawmaterialdetails_model->getAllResinMaterialCode();

        }


        // getting customer for creating table headers
        // checking already existing  stock if yes then get customer from the existing stock
        // if not set customer in db , then set '' empty string

        foreach ($resinMaterials as $key => $resinMaterial) {
            $materialCode = $resinMaterial['MaterialCode'];
            $resinMaterials[$key]['customers'] = $this->resinStockDetails_model
                ->select('customer')
                ->where('date >=', $startDate)
                ->where('date <=', $endDate)
                ->where('materialCode', $materialCode)
                ->first()['customer'] ?? '';
        }

        $resinMaterialCount = count($resinMaterials);

        $data['resinMaterialCount'] = $resinMaterialCount;
        $data['resinMaterials']     = $resinMaterials;

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        return $this->loadViews("stock/resinStockDetails", $this->global, $data, NULL);
    }

    public function updateResinStockDetails()
    {


        $postData = $this->request->getPost();

        $updateResinStockDetailsData = json_decode($postData['updateResinStockDetails'], true);

        $updates = [];

        $inserts = [];

        foreach ($updateResinStockDetailsData as $data) {

            $date = $data['date'];
            $materialCode = $data['materialCode'];


            $dbData = [
                'date' => $data['date'],
                'materialCode' => $data['materialCode'],
                'customer' => $data['customer'],
                'opening' => $data['opening'],
                'receipt' => $data['receipt'],
                'used' => $data['used'],
                'balanceStock' => $data['balanceStock'],
            ];

            $resultExists = $this->resinStockDetails_model
                ->where('date', $date)
                ->where('materialCode', $materialCode)
                ->first();


            if (empty($resultExists)) {
                $inserts[] = $dbData;
            } else {
                $dbData['id'] = $resultExists['id'];
                $updates[] = $dbData;
            }
        }


        if (!empty($inserts)) {
            $this->resinStockDetails_model->insertBatch($inserts);
        }

        if (!empty($updates)) {

            $updateResult = $this->resinStockDetails_model->updateBatch($updates, 'id');

            if ($updateResult === FALSE) {
                echo "Error during update";
            } else {
                echo "Data Updated Successfully";
                return;
            }
        }

        echo "Data Saved Successfully";
    }


    //Gas Stock Details
    public function loadView_gasStockDetails()
    {

        if ($this->request->getMethod() === 'POST') {

            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);

        } else {
            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = "Gas Stock Details";


        $previousMonth = DateTime::createFromFormat('Y-m', $month)->modify('-1 month')->format('Y-m');
        $previousMonthStartDate = "$previousMonth-01";
        $previousMonthEndDate = date("Y-m-t", strtotime($previousMonthStartDate));
        $data['previousMonthGasStockDetails'] = $this->gasStockDetails_model
            ->select('date,balanceStock')
            ->where('date =', $previousMonthEndDate)
            ->orderBy('date', 'desc')
            ->findAll();

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));

        $data['gasStockDetails'] = $this->gasStockDetails_model
            ->select(
                't_gasStockDetails.*,
            drier_summary.drierMachineGasconsumption AS drierMachineGasConsumption,
            drier_summary.driedSand AS sandDried,
            coating_summary.coatingMachineGasconsumption,
            coating_summary.coatedSand'
            )
            // Subquery with early date filtering
            ->join(
                '(SELECT date, 
                    SUM(totalGasconsumption) AS coatingMachineGasconsumption,
                    SUM(totalCoatingSandInKg) / 1000 AS coatedSand
            FROM t_coatingMachineDetails
            WHERE is_active = 1     
            AND date >= ' . $this->db->escape($startDate) . ' 
            AND date <= ' . $this->db->escape($endDate) . '
            GROUP BY date
            ) AS coating_summary',
                'coating_summary.date = t_gasStockDetails.date',
                'left'
            )
            ->join(
                '(SELECT date, 
                    SUM(total_gas_consumption) AS drierMachineGasconsumption,
                    SUM(sand_dried_qty)        AS driedSand
            FROM t_drierMachineDetails 
            WHERE date >= ' . $this->db->escape($startDate) . ' 
            AND date <= ' . $this->db->escape($endDate) . '
            GROUP BY date
            ) AS drier_summary',
                'drier_summary.date = t_gasStockDetails.date',
                'left'
            )

            ->where('t_gasStockDetails.date >=', $startDate)
            ->where('t_gasStockDetails.date <=', $endDate)
            ->groupBy('t_gasStockDetails.date')
            ->findAll();



        $data['month'] = DateTime::createFromFormat('Y-m', $month)->format('M-Y');

        return $this->loadViews("stock/gasStockDetails", $this->global, $data, NULL);
    }

    public function updateGasStockDetails()
    {

        $postData = $this->request->getPost();

        $updateGasStockDetailsData = json_decode($postData['updateGasStockDetails'], true);

        $updates = [];

        $inserts = [];

        foreach ($updateGasStockDetailsData as $data) {

            $date = $data['date'];


            $dbData = [
                'date' => $data['date'] ,
                'opening' => $data['opening'] ,
                'purchaseBharath' => $data['purchaseBharath'] ,
                'purchaseIndian' => $data['purchaseIndian'] ,
                'total' => $data['total'] ,
                'consumption' => $data['consumption'] ,
                'balanceStock' => $data['balanceStock'] ,
                'trp_panel_gas_consumption' => $data['trpPanelGasConsumption'] ,
                'trp_physical_gas_consumption' => $data['trpPhysicalGasConsumption'] ,
                'trp_sand_production' => $data['trpSandProduction'] ,
                'rotary_drier_consumption' => $data['rotaryDrierConsumption']   
            ];

            $resultExists = $this->gasStockDetails_model
                ->where('date', $date)
                ->first();


            if (empty($resultExists)) {
                $inserts[] = $dbData;
            } else {
                $dbData['id'] = $resultExists['id'];
                $updates[] = $dbData;
            }

        }


        if (!empty($inserts)) {
            $this->gasStockDetails_model->insertBatch($inserts);
        }

        if (!empty($updates)) {

            $updateResult = $this->gasStockDetails_model->updateBatch($updates, 'id');

            if ($updateResult === FALSE) {
                echo "Error during update";
            } else {
                echo "Data Updated Successfully";
                return;
            }
        }

        echo "Data Saved Successfully Warning..!! Kindly Update the next subsequent month Gas Stock If older month Gas Stock Updated..!!";
    }

    private function updateGasStockConsumption($date, $consumption)
    {

        $resultExists = $this->gasStockDetails_model
            ->where('date', $date)
            ->first();

        if ($resultExists) {


            if ($date instanceof DateTime) {
                $date = $date->format('Y-m-d');
            } elseif (!strtotime($date)) {
                throw new \Exception("Invalid date format provided.");
            } else {
                $date = date('Y-m-d', strtotime($date));
            }

            $endDate = date('Y-m-t', strtotime($date));


            //what happens if the updation is on the last day of the month?
            $resultExists = $this->gasStockDetails_model
                ->where('date >=', $date)
                ->where('date <=', $endDate)
                ->orderBy('date', 'asc')
                ->findAll();

            $updatedOpeningStock = 0;
            $updates = [];


            foreach ($resultExists as $index => $result) {

                if ($index == 0) {
                    $result['consumption'] = (float)($result['consumption']) + (float)($consumption);
                    $result['total'] = (float)$result['opening'] + (float)$result['purchaseBharath'] + (float)$result['purchaseIndian'];
                    $result['balanceStock'] = $result['total'] - $result['consumption'];
                    $updatedOpeningStock = (int)$result['balanceStock'];
                } else {
                    $result['opening'] = (float)$updatedOpeningStock;
                    $result['total'] = (float)$result['opening'] + (float)$result['purchaseBharath'] + (float)$result['purchaseIndian'];
                    $result['balanceStock'] = (float)$result['total'] - (float)$result['consumption'];
                    $updatedOpeningStock = (int)$result['balanceStock'];
                }


                $updates[] = $result;
            }

            if (!empty($updates)) {
                $result = $this->gasStockDetails_model->updateBatch($updates, 'id');
                return ($result !== false && $result > 0) ? $result : 0;
            } else {
                return 0;
            }
        } else {



            $previousMonthDate = new DateTime($date);
            $previousMonthDate = $previousMonthDate->modify('first day of this month')
                ->modify('-1 day')
                ->format('Y-m-d');



            $previousMonthResultExists = $this->gasStockDetails_model
                ->where('date', $previousMonthDate)
                ->first();



            $opening = 0;

            if (!empty($previousMonthResultExists) && isset($previousMonthResultExists['balanceStock'])) {
                $opening = $previousMonthResultExists['balanceStock'];
            }



            $startDate = DateTime::createFromFormat('Y-m-d', $date)->modify('first day of this month')->format('Y-m-d');
            $endDate = DateTime::createFromFormat('Y-m-d', $date)->modify('last day of this month')->format('Y-m-d');

            $datesInMonth = [];
            $inserts = [];

            $period = new DatePeriod(
                new DateTime($startDate),
                new DateInterval('P1D'),
                (new DateTime($endDate))->modify('+1 day')
            );

            foreach ($period as $day) {
                $datesInMonth[] = $day->format('Y-m-d');
            }

            foreach ($datesInMonth as $datesInMonthIndex => $dateInMonth) {

                //update previousMonthResultExists
                $balanceStock = $opening;
                $consumptionForDate = 0;
                if ($dateInMonth == $date) {
                    $consumptionForDate = $consumption;
                    $balanceStock = $opening - $consumption;
                }

                $inserts[] = [
                    'date' => $dateInMonth,
                    'opening' => $opening,
                    'purchaseBharath' => Null,
                    'purchaseIndian' => Null,
                    'total' => Null,
                    'consumption' => $consumptionForDate,
                    'balanceStock' => $balanceStock
                ];

                $opening = $balanceStock;
            }

            if (!empty($inserts)) {
                $result = $this->gasStockDetails_model->insertBatch($inserts);
                return ($result !== false && $result > 0) ? $result : 0;
            } else {
                return 0;
            }
        }
    }

    public function trpSandUseStockDetails(){
        
    
        if ($this->request->getMethod() === 'POST') {
            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;
        } else {
            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Trp Sand Use Stock Details';

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));
        $data['trpSandUseStockDetails'] = $this->TrpSandUseStock_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->orderBy('date', 'asc')
            ->findAll();

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

        return $this->loadViews("stock/trpSandUseStockDetails", $this->global, $data, NULL);
       

    }

    public function updateTrpSandUseStockDetails(){

        $postData = $this->request->getPost();

        $updateTrpSandUseStockDetailsData = json_decode($postData['updateTrpSandUseStockDetails'], true);

        $updates = [];

        $inserts = [];

        foreach ($updateTrpSandUseStockDetailsData as $data) {

            $data['date'] = DateTime::createFromFormat('d-m-Y', $data['date'])->format('Y-m-d');

            $date = $data['date'];

            $dbData = [
                'date' => $data['date'],
                'rough_kgs' => $data['rough_kgs'],
                'fine_kgs'  => $data['fine_kgs'],
                'total_kgs' => $data['total_kgs'],
                'customer_name'  => $data['customer_name']
            ];

            $resultExists = $this->TrpSandUseStock_model
                ->where('date', $date)
                ->first();


            if (empty($resultExists)) {
                $inserts[] = $dbData;
            } else {
                $dbData['id'] = $resultExists['id'];
                $updates[] = $dbData;
            }
        }

        if (!empty($inserts)) {
            $this->TrpSandUseStock_model->insertBatch($inserts);
        }

        if (!empty($updates)) {

            $updateResult = $this->TrpSandUseStock_model->updateBatch($updates, 'id');

            if ($updateResult === FALSE) {
                echo "Error during update";
            } else {
                echo "Data Updated Successfully";
                return;
            }
        }

        echo "Data Saved Successfully";
     }



     public function trpProductionDetails(){

        
        if ($this->request->getMethod() === 'POST') {
            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);


        } else {
           
            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
          
        }       

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Trp production Details';

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));

        $trpProductionMaintenanceData = $this->TrpProductionMaintenance_model
        ->where('date >=', $startDate)
        ->where('date <=', $endDate)
        ->find();

        if(empty($trpProductionMaintenanceData)){

            $inserts = [];

            $inserts = $this->generateDummyData($startDate, $endDate);

            $freshEntry = true ;

            $data['trpProductionMaintenanceData'] = $this->updateTrpProductionDetails($inserts ,$freshEntry);

        }


    
        $result = $this->TrpProduction_model->trpProductionDetails($startDate,$endDate);

        $data['trpProductionDetails'] = $result[0] ;

        $data['crsClientList']        = $result[1] ;

        $data['wcsSupplierList']      = $result[2] ;



        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;


       // return $this->response->setJSON($data);


        return $this->loadViews("stock/trpProductionStockDetails", $this->global, $data, NULL);
       
     }





     public function updateTrpProductionDetails($inserts = null, $freshEntry = false)
     {

        
         $postData['updateTrpProductionDetails'] = json_decode($this->request->getPost('updateTrpProductionDetails'),true);
        
     

         if (empty($postData['updateTrpProductionDetails'])) {
             if (empty($inserts)) {
                 return $this->response->setJSON(['error' => 'No data found to update']);
             } else {
                 $postData['updateTrpProductionDetails'] = $inserts;
             }
         }
     
         $updateTrpProductionDetails = $postData['updateTrpProductionDetails'];
     
         // Extract all dates from input data
         $dates = array_column($updateTrpProductionDetails, 'Date');
         $formattedDates = array_map(fn($date) => $this->convertToDateWithFlexibleFormats($date, ["d-m-Y", "Y-m-d", "m/d/Y", "m-d-Y"], "Y-m-d"), $dates);
     
         // Fetch all existing records in a single query per table
         $existingMaintenance = $this->TrpProductionMaintenance_model->whereIn('date', $formattedDates)->findAll();
         $existingProduction = $this->TrpProduction_model->whereIn('date', $formattedDates)->findAll();
         $existingWaste = $this->TrpProductionWaste_model->whereIn('date', $formattedDates)->findAll();
     
         // Map existing records by date for quick lookup
         $existingMaintenanceMap = array_column($existingMaintenance, null, 'date');
         $existingProductionMap = array_column($existingProduction, null, 'date');
         $existingWasteMap = array_column($existingWaste, null, 'date');
     
         $insertMaintenance = [];
         $updateMaintenance = [];
         $insertProduction = [];
         $updateProduction = [];
         $insertWaste = [];
         $updateWaste = [];
     
         foreach ($updateTrpProductionDetails as $data) {
             $date = $this->convertToDateWithFlexibleFormats($data['Date'], ["d-m-Y", "Y-m-d", "m/d/Y", "m-d-Y"], "Y-m-d");
     
             // Data arrays
             $dbDataTrpMaintenance = [
                 'date' => $date,
                 'openingTime' => $data['openingTime'],
                 'closingTime' => $data['closingTime'],
                 'totalHours' => $data['totalHours'],
                 'coldStart' => $data['coldStart'],
                 'breakdownHours' => $data['breakdownHours'],
                 'burnerFiringHours' => $data['burnerFiringHours'],
                 'sandFeedingHours' => $data['sandFeedingHours'],
                 'workingPersonEngineers' => $data['workingPersonEngineers'],
                 'workingPersonSupervisiors' => $data['workingPersonSupervisiors'],
                 'workingPersonOperators' => $data['workingPersonOperators'],
                 'rollerDrivers' => $data['rollerDrivers'],
                 'natureOfMaintenance' => $data['natureOfMaintenance'],
                 'location' => $data['location'],
                 'description' => $data['description']
             ];
     
             $dbDataTrpProduction = [
                 'date' => $date,
                 'gasReceiptBg' => $data['gasReceiptBg'],
                 'gasReceiptPg' => $data['gasReceiptPg'],
                 'physicalGasConsumption' => $data['physicalGasConsumption'],
                 'trpPlusDrierGasConsumption' => $data['trpPlusDrierGasConsumption'],
                 'trpPhysicalGasPerTon' => $data['trpPhysicalGasPerTon'],
                 'panelGasConsumption' => $data['panelGasConsumption'],
                 'panelGasPerTon' => $data['panelGasPerTon'],
                 'edRunningHours' => $data['edRunningHours'],
                 'edProduction' => $data['edProduction'],
                 'edUsage' => $data['edUsage'],
                 'trpProduction' => $data['trpProduction'],
                 'trpProductionPerHour' => $data['trpProductionPerHour'],
                 'waterReceipt' => $data['waterReceipt'],
                 'waterConsumption' => $data['waterConsumption'],
                 'ebReading' => $data['ebReading'],
                 'ebReadingPerUnitTon' => $data['ebReadingPerUnitTon'],
             ];
     
             $dbDataTrpWaste = [
                 'date' => $date,
                 'msSeperation' => $data['msSeperation'],
                 'edWaste' => $data['edWaste'],
                 'coolerBags' => $data['coolerBags'],
                 'edPlus20Waste' => $data['edPlus20Waste'],
                 'cycloneWaste' => $data['cycloneWaste'],
             ];
     
             // Check if data already exists
             if (isset($existingMaintenanceMap[$date])) {
                 $dbDataTrpMaintenance['id'] = $existingMaintenanceMap[$date]['id'];
                 $updateMaintenance[] = $dbDataTrpMaintenance;
             } else {
                 $insertMaintenance[] = $dbDataTrpMaintenance;
             }
     
             if (isset($existingProductionMap[$date])) {
                 $dbDataTrpProduction['id'] = $existingProductionMap[$date]['id'];
                 $updateProduction[] = $dbDataTrpProduction;
             } else {
                 $insertProduction[] = $dbDataTrpProduction;
             }
     
             if (isset($existingWasteMap[$date])) {
                 $dbDataTrpWaste['id'] = $existingWasteMap[$date]['id'];
                 $updateWaste[] = $dbDataTrpWaste;
             } else {
                 $insertWaste[] = $dbDataTrpWaste;
             }
         }
     
         // Start transaction
         $this->db->transBegin();
     
         try {
             // Insert new records in batch
             if (!empty($insertMaintenance)) {
                 $this->TrpProductionMaintenance_model->insertBatch($insertMaintenance);
             }
             if (!empty($insertProduction)) {
                 $this->TrpProduction_model->insertBatch($insertProduction);
             }
             if (!empty($insertWaste)) {
                 $this->TrpProductionWaste_model->insertBatch($insertWaste);
             }
     
             // Update existing records in batch
             if (!empty($updateMaintenance)) {
                 $this->TrpProductionMaintenance_model->updateBatch($updateMaintenance, 'id');
             }
             if (!empty($updateProduction)) {
                 $this->TrpProduction_model->updateBatch($updateProduction, 'id');
             }
             if (!empty($updateWaste)) {
                 $this->TrpProductionWaste_model->updateBatch($updateWaste, 'id');
             }
     
             // Commit transaction if successful
             $this->db->transCommit();
     
             if (!$freshEntry) {
                 echo "Data Saved Successfully";
             }
         } catch (\Exception $error) {
             // Rollback transaction on error
             $this->db->transRollback();
             echo "An error occurred: " . $error->getMessage();
         }
     }
     
     



    public function generateDummyData($startDate, $endDate)
    {
        $datesInMonth = [];
        $inserts = [];
        $trpAbstract = [] ;

        $period =   new DatePeriod(
                    new DateTime($startDate),
                    new DateInterval('P1D'),
                   (new DateTime($endDate))->modify('+1 day')
        );

        foreach ($period as $day) {
            $datesInMonth[] = $day->format('Y-m-d');
        }

        foreach ($datesInMonth as $datesInMonthIndex => $dateInMonth) {

            if($datesInMonthIndex == 0){

                $trpAbstractParticulars =$this->trpAbstractParticularsModel->findAll();

                    foreach($trpAbstractParticulars as $index => $trpAbstractParticular){

                        $trpAbstract[] = [
                            'date'              => $dateInMonth ,
                            'abs_opening_stock' => 0 ,
                            'abs_physical_stock'=> 0 ,
                            'abs_remarks'       => " " ,
                            'abs_particular_id' => $trpAbstractParticular['id'],
                        ];
                    }

                
            }


            $inserts[] = [
                'Date' => $dateInMonth,
                'openingTime' => " ",
                'closingTime' => " ",
                'totalHours' => " ",
                'coldStart' => " ",
                'breakdownHours' => " ",
                'burnerFiringHours' => " ",
                'sandFeedingHours' => " ",
                'workingPersonEngineers' => " ",
                'workingPersonSupervisiors' => " ",
                'workingPersonOperators' => " ",
                'rollerDrivers' => " ",
                'natureOfMaintenance' => '',
                'location' => '',
                'description' => '',
                'gasReceiptBg' => " ",
                'gasReceiptPg' => " ",
                'physicalGasConsumption' => " ",
                'trpPlusDrierGasConsumption' => " ",
                'trpPhysicalGasPerTon' => " ",
                'panelGasConsumption' => " ",
                'panelGasPerTon' => " ",
                'edRunningHours' => " ",
                'edProduction' => " ",
                'edUsage' => " ",
                'trpProduction' => " ",
                'trpProductionPerHour' => " ",
                'waterReceipt' => " ",
                'waterConsumption' => " ",
                'ebReading' =>" ",
                'ebReadingPerUnitTon' =>" ",
                'msSeperation' => " ",
                'edWaste' => " ",
                'coolerBags' =>" ",
                'edPlus20Waste' => " ",
                'cycloneWaste' => " "
            ];
        }

        return $inserts;
    }











     

    // --------------------------------------------gwm----------------------------------------------


    public function getMonthDatesFromInput($monthYear)
    {

        $date = DateTime::createFromFormat('M-Y', $monthYear);

        if (!$date) {
            return "Invalid date format. Use 'M-yyyy' format.";
        }

        $year = $date->format('Y');
        $month = $date->format('m');

        $totalDays = cal_days_in_month(CAL_GREGORIAN, $month, $year);

        $dates = [];
        for ($day = 1; $day <= $totalDays; $day++) {

            $currentDate = DateTime::createFromFormat('Y-m-d', "$year-$month-$day");

            $dates[] = [
                'readable' => $currentDate->format('d-m-Y'),
                'database' => $currentDate->format('Y-m-d')
            ];
        }

        return $dates;
    }

    public function generateTimeOptions()
    {
        $times = [];
        $start = strtotime('00:00'); // Start at midnight (12:00 AM)
        $end = strtotime('23:45');   // End at 11:45 PM

        while ($start <= $end) {
            $timeValue = date('H:i', $start);  // 24-hour format for value
            $timeLabel = date('h:i a', $start); // 12-hour format with AM/PM for display
            $times[$timeValue] = $timeLabel; // Store time in associative array
            $start = strtotime('+15 minutes', $start); // Increment by 15 minutes
        }

        return $times;
    }

    
    public function drierMachineDetails()
    {


        //drier will be processing different method than other stock in case of session stock month and date format for generating 
        //dummy data and updating the data . be cautious while updating the code..!!

        if ($this->request->getMethod() === 'POST') {

            $currentMonth = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $currentMonth); //in M-Y format

            $formattedDate = $date->format('Y-m'); //in Y-m format  


            $session = session ();

            $session->set('stock_month',$formattedDate);


        } else {

            $session = session();

            $currentMonth = $session->get('stock_month');

            if (empty($currentMonth)) {
                $currentMonth = date('M-Y'); // Default to the current month
            }else{
                $currentMonth =  DateTime::createFromFormat('Y-m', $currentMonth); // in Y-m format

                $currentMonth = $currentMonth->format('M-Y'); // in M-Y format
            }
        }

        $monthData = $this->getMonthDatesFromInput($currentMonth);

        $data['startDate'] = $monthData[0]['database'];
        $data['endDate'] = $monthData[count($monthData) - 1]['database'];
        $data['timeDropdown'] = $this->generateTimeOptions();
        $data['supplierData'] = $this->supplier_model->supplierlisting();

        $data['drierDetails'] = $this->drierMachineDetails_model
        ->where('date >=', $data['startDate'])
        ->where('date <=', $data['endDate'])
        ->orderBy('date','asc')
        ->findAll();


        $data['datefordropdown'] = $currentMonth;

        $this->global['pageTitle'] = 'Drier Details';
        $this->loadViews("stock/drierMachineDetails", $this->global, $data, NULL);


    }

    public function addOrEditdrierMachineDetails()
    {
        
    
            $data = $this->request->getPost();
            
            $drierData[] = $this->mapDrierEntry($data);
        
    
        $this->db->transBegin();
        try {
            $inserts = [];
            $updates = [];
    
            foreach ($drierData as $row) {
                $existingRow = $row['id'];
                $data = $row;

    
                if (($existingRow)) {
                  //  dd("inside update");                
                    $existingRow = $this->drierMachineDetails_model->where('id', $row['id'] ?? '')->first();
               
                    $this->handleGasStockUpdate($existingRow, $row);
                    $updates[] = $data;
                } else {
                  //  dd("inside insert");
                    $this->updateGasStockConsumption($data['date'], $data['total_gas_consumption']);
                    $inserts[] = $data;
                }
            }
    
            if (!empty($inserts)) {
                $this->drierMachineDetails_model->insertBatch($inserts);
            }
    
            if (!empty($updates)) {
                $this->drierMachineDetails_model->updateBatch($updates, 'id');
            }
    
            if ($this->db->transStatus() === false) {
                throw new \Exception('Transaction failed due to database error.');
            }
    
            $this->db->transCommit();

                return redirect()->to("/drierMachineDetails")->with('success', "Data Saved Successfully");

            } catch (\Exception $error) {
                $this->db->transRollback();
                return redirect()->back()->with('error', ' ' . $error->getMessage());
            }
    }
    
    /**
     * Maps input row to expected format.
     */
    private function mapDrierEntry(array $data): array
    {
        return [
            'id'                    => $data['id'] ?? null,
            'date'                  => $this->convertToDateWithFlexibleFormats($data['date'], ["d-m-Y", "Y-m-d", "m/d/Y", "m-d-Y"], "Y-m-d"),
            'drier_on_time'         => $data['drier_on_time'],
            'drier_off_time'        => $data['drier_off_time'],
            'drier_running_hours'   => $data['drier_running_hours'],
            'supplier_name'         => $data['supplier_name'],
            'input_sand_moisture'   => $data['input_sand_moisture'],
            'total_gas_consumption' => $data['total_gas_consumption'],
            'gas_per_ton'           => $data['gas_per_ton'],
            'input_sand_qty'        => $data['input_sand_qty'],
            'moisture_loss_qty'     => $data['moisture_loss_qty'],
            'sand_dried_qty'        => $data['sand_dried_qty'],
            'qty_per_hours'         => $data['qty_per_hours'],
            'dust_qty'              => $data['dust_qty'],
            'customer_name'         => $data['customer_name']
        ];
    }
    
    /**
     * Updates gas stock consumption if the value changes.
     */
    private function handleGasStockUpdate($existingRow, $newRow)
    {
        $existingConsumption = $existingRow['total_gas_consumption'];
        $updatedConsumption = $newRow['total_gas_consumption'];
    
        if ($existingConsumption != $updatedConsumption) {
            $changeInConsumption = $updatedConsumption - $existingConsumption;
            $this->updateGasStockConsumption($existingRow['date'], $changeInConsumption);
        }
    }
    
     

    function convertToDateWithFlexibleFormats($dateInput, array $inputFormats, string $outputFormat): ?string
    {
        // If it's already a DateTime object, just format it
        if ($dateInput instanceof DateTime) {
            return $dateInput->format($outputFormat);
        }

        // If it's a string, attempt to parse it
        if (is_string($dateInput)) {
            foreach ($inputFormats as $format) {
                $date = DateTime::createFromFormat($format, $dateInput);
                if ($date) {
                    return $date->format($outputFormat);
                }
            }
        }

        return $dateInput;
    }

    public function powerConsumptionDetails(){

         
        if ($this->request->getMethod() === 'POST') {

            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month); //in M-Y format

            $formattedDate = $date->format('Y-m'); //in Y-m format  

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);


        } else {

            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Power Consumption Stock Details';


        // Get the previous month's last date power consumption stock details for next month updation

        $previousMonth = DateTime::createFromFormat('Y-m', $month)->modify('-1 month')->format('Y-m');
        $previousMonthStartDate = "$previousMonth-01";
        $previousMonthEndDate = date("Y-m-t", strtotime($previousMonthStartDate));

        $data['previousMonthPowerConsumptionStockDetails'] = $this->powerConsumptionDetails_model
            ->select(['machine_id', 'date', 'closing_units'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)
            ->groupBy(['machine_id', 'date'])
            ->orderBy('date', 'desc')
            ->orderBy('machine_id', 'asc')
            ->findAll();

        $data['previousMonthTotalPowerMachineStockDetails'] = $this->powerConsumptionSummary_model
            ->select(['id', 'date', 'final_reading'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)        
            ->groupBy(['id', 'date'])
            ->orderBy('date', 'desc')
            ->findAll();



        // checking in database if the data is available for the month

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));

        $data['powerConsumptionStockDetails'] = $this->powerConsumptionDetails_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->groupBy(['machine_id', 'date'])
            ->orderBy('date', 'asc')
            ->orderBy('machine_id', 'asc')
            ->findAll();

        $data['totalPower'] = $this->powerConsumptionSummary_model       
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->orderBy('date', 'asc')
            ->findAll();

        // Initialize an empty array to hold the grouped data
        $data['groupedPowerConsumptionStockDetails'] = [];

        // Temporary array to store grouped data by date
        $groupedByDate = [];

        // Group by 'date'
        foreach ($data['powerConsumptionStockDetails'] as $detail) {
            $date = $detail['date'];

            // Initialize the outer array for this date if it doesn't exist
            if (!isset($groupedByDate[$date])) {
                $groupedByDate[$date] = [];
            }

            /*******************************************************************************************************************
             creating an sub array (inner array) for date wise and append the detail into an array as sub-array 

             $groupedByDate[] outer array

             $groupedByDate[$date]
             will look like [[material1],[material2],[material3],[material4],[material5]] inner array

             the above process is done for single row (date wise) and the same process is repeated for all the rows
            *******************************************************************************************************************/

            $groupedByDate[$date][] = $detail;
        }

        // Reset the structure to have indexed arrays without the date keys
        $data['groupedPowerConsumptionStockDetails'] = array_values($groupedByDate);


        // getting electric machines for creating table headers
        // checking already existing  stock if yes then get the electric machines id from the existing stock
        // if not get all the electric machines from the factory Machine master  table

        if (!empty($data['groupedPowerConsumptionStockDetails'])) {
           
            $result = $groupedByDate[$date];

            $distinctMachineId = [];

            foreach ($result as $index => $eachResult) {
                $distinctMachineId[] = $result[$index]['machine_id'];
            }

            $electricMachines = $this->factoryMachine_model
            ->whereIn('id', $distinctMachineId) 
            ->orderBy('id', 'asc')
            ->get()
            ->getResultArray();

      
        } else {

            $electricMachines = $this->factoryMachine_model
            ->where('is_active', 1)
            ->where('energy_type', 'Electric')
            ->orderBy('id', 'asc') 
            ->get()
            ->getResultArray();

        }



        $electricMachinesCount = count($electricMachines);

        $data['electricMachinesCount'] = $electricMachinesCount;
        $data['electricMachines']     = $electricMachines;

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate;

       // return  $this->response->setJSON(['status' =>'success' ,'message' => $data['electricMachines']]);

        return $this->loadViews("stock/powerConsumptionDetails", $this->global, $data, NULL);   

    }

    public function updatePowerConsumptionDetails(){

        //pm stands for power machine
        
        
        $postData = $this->request->getPost();

        $updatePowerConsumptionDetailsData = json_decode($postData['updatePowerConsumptionDetails'], true);

        $updateTotalPmDetailsData = $updatePowerConsumptionDetailsData[0];
        $updatePmDetailsData      = $updatePowerConsumptionDetailsData[1];
        
        //PmR stands for power machine readings 

        $updatesPmR = [];
        $insertsPmR = [];

        $updatesTotalPmR  = []; 
        $insertsTotalPmR = [];

                // Fetch existing records in bulk for power machine details
                $dates = array_column($updatePmDetailsData, 'date');
                $machineIds = array_column($updatePmDetailsData, 'machine_id');
                $existingPmRecords = $this->powerConsumptionDetails_model
                    ->whereIn('date', $dates)
                    ->whereIn('machine_id', $machineIds)
                    ->findAll();
            
                $existingPmMap = [];
                foreach ($existingPmRecords as $record) {
                    $existingPmMap[$record['date']][$record['machine_id']] = $record;
                }
            
                foreach ($updatePmDetailsData as $data) {
                    $date = $data['date'];
                    $machineId = $data['machine_id'];
            
                    $dbData = [
                        'date' => $data['date'],
                        'machine_id' => $data['machine_id'],
                        'opening_units' => $data['opening_units'],
                        'closing_units' => $data['closing_units'],
                        'total_units' => $data['total_units'],
                    ];
            
                    if (isset($existingPmMap[$date][$machineId])) {
                        $dbData['id'] = $existingPmMap[$date][$machineId]['id'];
                        $updatesPmR[] = $dbData;
                    } else {
                        $insertsPmR[] = $dbData;
                    }
                }
            
                // Fetch existing records in bulk for power stock summary
                $dates = array_column($updateTotalPmDetailsData, 'date');
                $existingTotalPmRecords = $this->powerConsumptionSummary_model
                    ->whereIn('date', $dates)
                    ->findAll();
            
                $existingTotalPmMap = [];
                foreach ($existingTotalPmRecords as $record) {
                    $existingTotalPmMap[$record['date']] = $record;
                }
            
                foreach ($updateTotalPmDetailsData as $data) {
                    $date = $data['date'];
            
                    $dbData = [
                        'date' => $data['date'],
                        'opening_reading' => $data['opening_reading'],
                        'final_reading'   => $data['final_reading'],
                        'total_reading'   => $data['total_reading'],
                        'total_units'     => $data['total_units'],
                        'average_pf'      => $data['average_pf'],
                        'present_pf'      => $data['present_pf'],
                        'md'              => $data['md'],
                        'mf'              => $data['mf']
                    ];
            
                    if (isset($existingTotalPmMap[$date])) {
                        $dbData['id'] = $existingTotalPmMap[$date]['id'];
                        $updatesTotalPmR[] = $dbData;
                    } else {
                        $insertsTotalPmR[] = $dbData;
                    }
                }
            
                // Start the transaction
                $this->db->transBegin();
            
                try {
                    if (!empty($insertsPmR)) {
                        $this->powerConsumptionDetails_model->insertBatch($insertsPmR);
                    }
            
                    if (!empty($updatesPmR)) {
                        $this->powerConsumptionDetails_model->updateBatch($updatesPmR, 'id');
                    }
            
                    if (!empty($insertsTotalPmR)) {
                        $this->powerConsumptionSummary_model->insertBatch($insertsTotalPmR);
                    }
            
                    if (!empty($updatesTotalPmR)) {
                        $this->powerConsumptionSummary_model->updateBatch($updatesTotalPmR, 'id');
                    }
            
                    // Commit the transaction if all operations are successful
                    $this->db->transCommit();
                    echo "Data Saved Successfully";
            
                } catch (\Exception $error) {
                    // Rollback the transaction in case of any errors
                    $this->db->transRollback();
                    echo "An error occurred: " . $error->getMessage();
                }

    }



    public function dieselMachineStockDetails(){

        
        if ($this->request->getMethod() === 'POST') {

            $month = $this->request->getPost('month');

            $date = DateTime::createFromFormat('M-Y', $month);

            $formattedDate = $date->format('Y-m');

            $month = $formattedDate;

            $session = session ();

            $session->set('stock_month',$month);

        } else {

            $session = session();

            $month = $session->get('stock_month');

            if (empty($month)) {
                $month = date('Y-m'); // Default to the current month
            }
        }

        $data = [];

        $data['month'] = $month;

        $this->global['pageTitle'] = 'Diesel Machine Stock Details';


        // Get the previous month's last date resin stock details for next month updation

        $previousMonth = DateTime::createFromFormat('Y-m', $month)->modify('-1 month')->format('Y-m');
        $previousMonthStartDate = "$previousMonth-01";
        $previousMonthEndDate = date("Y-m-t", strtotime($previousMonthStartDate));

        $data['previousMonthDieselMachineStockDetails'] = $this->factoryVehicleDieselDetails_model
            ->select(['machine_id', 'date', 'closing_reading'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)
            ->groupBy(['machine_id', 'date'])
            ->orderBy('date', 'desc')
            ->orderBy('machine_id', 'asc')
            ->findAll();


        $data['previousMonthTotalDieselMachineStockDetails'] = $this->factoryVehicleDieselStockSummary_model
            ->select(['id', 'date', 'balance_stock'])
            ->distinct()
            ->where('date =', $previousMonthEndDate)
            ->groupBy(['id', 'date'])
            ->orderBy('date', 'desc')
            ->findAll();



        // checking in database if the data is available for the month

        $startDate = "$month-01";
        $endDate = date("Y-m-t", strtotime($startDate));

        $data['dieselMachineStockDetails'] = $this->factoryVehicleDieselDetails_model
            ->where('date >=', $startDate)
            ->where('date <=', $endDate)
            ->groupBy(['machine_id', 'date'])
            ->orderBy('date', 'asc')
            ->orderBy('machine_id', 'asc')
            ->findAll();


        $data['totalDiesel'] = $this->factoryVehicleDieselStockSummary_model 
        ->where('date >=', $startDate)
        ->where('date <=', $endDate)
        ->orderBy('date', 'asc')
        ->findAll();

        // Initialize an empty array to hold the grouped data
        $data['groupedDieselMachineStockDetails'] = [];

        // Temporary array to store grouped data by date
        $groupedByDate = [];

        // Group by 'date'
        foreach ($data['dieselMachineStockDetails'] as $detail) {
            $date = $detail['date'];

            // Initialize the outer array for this date if it doesn't exist
            if (!isset($groupedByDate[$date])) {
                $groupedByDate[$date] = [];
            }

            /*******************************************************************************************************************
             creating an sub array (inner array) for date wise and append the detail into an array as sub-array 

             $groupedByDate[] outer array

             $groupedByDate[$date]
             will look like [[material1],[material2],[material3],[material4],[material5]] inner array

             the above process is done for single row (date wise) and the same process is repeated for all the rows
            *******************************************************************************************************************/

            $groupedByDate[$date][] = $detail;
        }

        // Reset the structure to have indexed arrays without the date keys
        $data['groupedDieselMachineStockDetails'] = array_values($groupedByDate);



        // getting diesel machines for creating table headers
        // checking already existing  stock if yes then get the diesel machines id from the existing stock
        // if not get all the diesel machines from the factory Machine master  table

        if (!empty($data['groupedDieselMachineStockDetails'])) {
           
            $result = $groupedByDate[$date];

            $distinctMachineId = [];

            foreach ($result as $index => $eachResult) {
                $distinctMachineId[] = $result[$index]['machine_id'];
            }

            $dieselMachines = $this->factoryMachine_model
            ->whereIn('id', $distinctMachineId) 
            ->orderBy('id', 'asc')
            ->get()
            ->getResultArray();

      
        } else {

            $dieselMachines = $this->factoryMachine_model
            ->where('is_active', 1)
            ->where('energy_type', 'Diesel')
            ->orderBy('id', 'asc') 
            ->get()
            ->getResultArray();

        }


      



        $dieselMachinesCount = count($dieselMachines);

        $data['dieselMachinesCount'] = $dieselMachinesCount;
        $data['dieselMachines']     =  $dieselMachines;

        $date = DateTime::createFromFormat('Y-m', $month);

        $formattedDate = $date->format('M-Y');

        $data['month'] = $formattedDate ;

      //  return  $this->response->setJSON(['status' =>'success' ,'message' => $data['dieselMachines']]);

        return $this->loadViews("stock/dieselStockDetails", $this->global, $data, NULL);    




    }

    public function updateDieselMachineDetails() {
        
        $postData = $this->request->getPost();
        $updateDmDetailsData = json_decode($postData['updateDieselMachineDetails'], true);
    
        $updateTotalDmDetailsData = $updateDmDetailsData[0];
        $updateDmDetailsData = $updateDmDetailsData[1];
    
        $updatesDmR = [];
        $insertsDmR = [];
        $updatesTotalDmR = [];
        $insertsTotalDmR = [];
    
        // Fetch existing records in bulk for diesel machine details
        $dates = array_column($updateDmDetailsData, 'date');
        $machineIds = array_column($updateDmDetailsData, 'machine_id');
        $existingDmRecords = $this->factoryVehicleDieselDetails_model
            ->whereIn('date', $dates)
            ->whereIn('machine_id', $machineIds)
            ->findAll();
    
        $existingDmMap = [];
        foreach ($existingDmRecords as $record) {
            $existingDmMap[$record['date']][$record['machine_id']] = $record;
        }
    
        foreach ($updateDmDetailsData as $data) {
            $date = $data['date'];
            $machineId = $data['machine_id'];
    
            $dbData = [
                'date' => $data['date'],
                'machine_id' => $data['machine_id'],
                'opening_reading' => $data['opening_reading'],
                'closing_reading' => $data['closing_reading'],
                'filling_diesel' => $data['filling_diesel'],
                'consumption' => $data['consumption'],
                'running_hours' => $data['running_hours'],
                'mileage' => $data['mileage']
            ];
    
            if (isset($existingDmMap[$date][$machineId])) {
                $dbData['id'] = $existingDmMap[$date][$machineId]['id'];
                $updatesDmR[] = $dbData;
            } else {
                $insertsDmR[] = $dbData;
            }
        }
    
        // Fetch existing records in bulk for diesel stock summary
        $dates = array_column($updateTotalDmDetailsData, 'date');
        $existingTotalDmRecords = $this->factoryVehicleDieselStockSummary_model
            ->whereIn('date', $dates)
            ->findAll();
    
        $existingTotalDmMap = [];
        foreach ($existingTotalDmRecords as $record) {
            $existingTotalDmMap[$record['date']] = $record;
        }
    
        foreach ($updateTotalDmDetailsData as $data) {
            $date = $data['date'];
    
            $dbData = [
                'date' => $data['date'],
                'opening_stock' => $data['opening_stock'],
                'purchase_diesel' => $data['purchase_diesel'],
                'total_filling_diesel' => $data['total_filling_diesel'],
                'balance_stock' => $data['balance_stock']
            ];
    
            if (isset($existingTotalDmMap[$date])) {
                $dbData['id'] = $existingTotalDmMap[$date]['id'];
                $updatesTotalDmR[] = $dbData;
            } else {
                $insertsTotalDmR[] = $dbData;
            }
        }
    
        // Start the transaction
        $this->db->transBegin();
    
        try {
            if (!empty($insertsDmR)) {
                $this->factoryVehicleDieselDetails_model->insertBatch($insertsDmR);
            }
    
            if (!empty($updatesDmR)) {
                $this->factoryVehicleDieselDetails_model->updateBatch($updatesDmR, 'id');
            }
    
            if (!empty($insertsTotalDmR)) {
                $this->factoryVehicleDieselStockSummary_model->insertBatch($insertsTotalDmR);
            }
    
            if (!empty($updatesTotalDmR)) {
                $this->factoryVehicleDieselStockSummary_model->updateBatch($updatesTotalDmR, 'id');
            }
    
            // Commit the transaction if all operations are successful
            $this->db->transCommit();
            echo "Data Saved Successfully";
    
        } catch (\Exception $error) {
            // Rollback the transaction in case of any errors
            $this->db->transRollback();
            echo "An error occurred: " . $error->getMessage();
        }
    }

 


    











}