<?php

namespace App\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

use Doctrine\ORM\EntityManagerInterface;

use App\Entity\JobOrder;
use App\Entity\Warranty;
use App\Entity\SAPBattery;
use App\Entity\InvoiceItem;
use App\Entity\Battery;

use App\Ramcar\ServiceType;
use App\Ramcar\WarrantyClass;
use App\Ramcar\JOStatus;

use App\Service\WarrantyHandler;

use DateTime;

class GetFlawedWarrantiesCommand extends Command
{
    protected $em;
    protected $wh;
    protected $sapbatt_hash;

    public function __construct(EntityManagerInterface $em, WarrantyHandler $wh)
    {
        $this->em = $em;
        $this->wh = $wh;

        $this->loadSAPBatteries();

        parent::__construct();
    }

    protected function configure()
    {
        $this->setName('warranty:getflawedwarranties')
            ->setDescription('Get warranties that need to be fixed.')
            ->setHelp('Get flawed warranties')
            ->addArgument('start_date', InputArgument::REQUIRED, 'Start Date')
            ->addArgument('end_date', InputArgument::REQUIRED, 'End Date');
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $s_date = $input->getArgument('start_date');
        $e_date = $input->getArgument('end_date');

        $start_date = DateTime::createFromFormat('Ymd', $s_date);
        $end_date = DateTime::createFromFormat('Ymd', $e_date);
        $end_date->setTime(23, 59);

        $missing_warranties = [];
        $comm_private_warranties = [];
        $invalid_plate_numbers = [];
        $duplicate_warranties = [];
        $sdate_expiry_wrong_warranties = [];
        $no_expiry_dates = [];
        $no_sap_batteries = [];

        $first_results_set = $this->getFlawedWarranties($start_date, $end_date);
        //$third_results_set = $this->getDuplicateWarranties($start_date, $end_date);

        $missing_warranties = $first_results_set['missing'];
        $invalid_plate_numbers = $first_results_set['invalid_plate_number'];
        $comm_private_warranties = $first_results_set['commercial_private'];
        $sdate_expiry_wrong_warranties = $first_results_set['wrong_expiry_date'];
        $no_expiry_dates = $first_results_set['no_expiry_date'];
        $no_sap_batteries = $first_results_set['no_sap_battery'];

        // our warranty error categories: missing, commercial_private, invalid plate number, duplicate, start date of expiry computation wrong
        $this->outputResults($s_date, $e_date, $missing_warranties, $invalid_plate_numbers, $comm_private_warranties,
            $sdate_expiry_wrong_warranties, $no_expiry_dates, $no_sap_batteries, $duplicate_warranties);

        return 0;
    }

    protected function getFlawedWarranties($start_date, $end_date)
    {
        $em = $this->em;

        // get all job orders with battery new service type within date range
        $jo_query = $em->createQuery('select ii,i,jo,cv from App\Entity\InvoiceItem ii inner join ii.invoice i inner join i.job_order jo inner join jo.cus_vehicle cv join jo.customer c where ii.battery is not null and jo.service_type = :service_type and jo.date_schedule > :date_start and jo.date_schedule < :date_end and jo.status != :status');
        $jo_query->setParameter('service_type', ServiceType::BATTERY_REPLACEMENT_NEW)
            ->setParameter('date_start', $start_date)
            ->setParameter('date_end', $end_date)
            ->setParameter('status', JOStatus::CANCELLED);

        $jos = $jo_query->iterate();

        $invalids = [];
        $missings = [];
        $comm_privates = [];
        $date_expiry_wrongs = [];
        $no_expiries = [];
        $no_saps = [];

        foreach($jos as $row)
        {
            $invoice_item = $row[0];
            $invoice = $invoice_item->getInvoice();
            $jo = $invoice->getJobOrder();
            $cv = $jo->getCustomerVehicle();
            $customer = $jo->getCustomer();

            if ($invoice_item != null)
            {
                if($invoice_item->getBattery() != null)
                {
                    // manually retrieve the SAPBattery using the SAPCode
                    $battery_sap_code = $invoice_item->getBattery()->getSAPCode();
                    $found_battery = $this->findSAPBattery($battery_sap_code);
                    $sap_code = '\'' . $battery_sap_code . '\'';
                    if (!$found_battery)
                    {
                        $sap_code = 'NULL';
                    }

                    // have to use this erroneous setting of the warranty period
                    // to be able to find those warranties that were added with this warranty period.
                    // warranties found with this warranty period will be marked as commercial_private
                    $warranty_period = 0;
                    if ($invoice_item->getBattery()->getWarrantyPrivate() != null)
                    {
                        $warranty_period = $invoice_item->getBattery()->getWarrantyPrivate();
                    }
                    if ($invoice_item->getBattery()->getWarrantyCommercial() != null)
                    {
                        $warranty_period = $invoice_item->getBattery()->getWarrantyCommercial();
                    }
                    if ($invoice_item->getBattery()->getWarrantyTnv() != null)
                    {
                        $warranty_period = $invoice_item->getBattery()->getWarrantyTnv();
                    }

                    if ($invoice->getDateCreate() != null)
                    {
                        // check if plate number is "clean". 
                        if (!(Warranty::cleanPlateNumber($cv->getPlateNumber())))
                        {
                            $invalids[] = [
                                'jo_id' => $jo->getID(),
                                'plate_number' => $cv->getPlateNumber(),
                                'expiry_date' => '',
                            ];

                            continue;
                        }

                        // check if warranty already exists
                        $cleaned_plate_number = Warranty::cleanPlateNumber($cv->getPlateNumber());

                        // use date_create of invoice as start date, as decided in group chat
                        $purchase_date = $invoice->getDateCreate();
                        $date_purchase_str = $purchase_date->format('Y-m-d'); 
                        $date_purchase = DateTime::createFromFormat('Y-m-d', $date_purchase_str);

                        $expiry_date_date_create = $this->wh->computeDateExpire($purchase_date, $warranty_period);

                        $results_date_create = $em->getRepository(Warranty::class)->findBy(['plate_number' => $cleaned_plate_number, 
                            'date_purchase' => $date_purchase]);

                        if (empty($results_date_create))
                        {
                            // find warranties that used date_schedule for date_purchase
                            $missing_flag = true;
                            $jo_warranty_class = $jo->getWarrantyClass();

                            $warr_period = $this->getWarrantyPeriod($jo_warranty_class, $invoice_item);

                            // get date schedule
                            $datetime_schedule = $jo->getDateSchedule();
                            $datetime_schedule_str = $datetime_schedule->format('Y-m-d');
                            $date_scheduled = DateTime::createFromFormat('Y-m-d', $datetime_schedule_str);

                            $expiry_date_date_scheduled = $this->wh->computeDateExpire($date_scheduled, $warr_period);

                            // find warranties with date_schedule as the date_purchase
                            $warranties_date_scheduled = $em->getRepository(Warranty::class)->findBy(['plate_number' => $cleaned_plate_number, 
                                    'date_purchase' => $date_scheduled]);

                            if (!(empty($warranties_date_scheduled)))
                            {
                                $missing_flag = false;

                                foreach ($warranties_date_scheduled as $warranty_date_scheduled)
                                {
                                    // check if sap_code exists in battery
                                    $warr_sap_battery = $warranty_date_scheduled->getSAPBattery();
                                    if ($warr_sap_battery != null)
                                    {
                                        $warr_sap_code = $warr_sap_battery->getID();

                                        if ($warr_sap_code != null)
                                        {
                                            $batteries = $em->getRepository(Battery::class)->findBy(['sap_code' => $warr_sap_code]);
                                            if ($batteries == null)
                                            {
                                                $no_saps[] = [
                                                    'warranty_id' => $warranty_date_scheduled->getID(),
                                                    'plate_number' => $cleaned_plate_number,
                                                    'sap_code' => $warr_sap_code,
                                                ];
                                            }
                                        }
                                    }

                                    // wrong expiration date
                                    $date_expiry_wrongs[] = [
                                        'warranty_id' => $warranty_date_scheduled->getID(),
                                        'plate_number' => $cleaned_plate_number,
                                        'expiry_date' => $expiry_date_date_create->format('Y-m-d'),
                                    ];
                                }

                            }
                            else
                            {
                                // get date fulfill
                                $datetime_fulfilled = $jo->getDateFulfill();
                                if ($datetime_fulfilled != null)
                                {
                                    $datetime_fulfilled_str = $datetime_fulfilled->format('Y-m-d');
                                    $date_fulfilled = DateTime::createFromFormat('Y-m-d', $datetime_fulfilled_str);

                                    $expiry_date_date_create = $this->wh->computeDateExpire($date_fulfilled, $warr_period);

                                    // find warranties with date fulfilled as the date_purchase
                                    $warranties_date_fulfilled = $em->getRepository(Warranty::class)->findBy(['plate_number' => $cleaned_plate_number, 
                                        'date_purchase' => $date_fulfilled]);

                                    if (!(empty($warranties_date_fulfilled)))
                                    {
                                        $missing_flag = false;

                                        foreach ($warranties_date_fulfilled as $warranty_date_fulfilled)
                                        {
                                            // check if sap_code exists in battery
                                            $warr_sap_battery = $warranty_date_fulfilled->getSAPBattery();
                                            if ($warr_sap_battery != null)
                                            {
                                                $warr_sap_code = $warr_sap_battery->getID();

                                                if ($warr_sap_code != null)
                                                {
                                                    $batteries = $em->getRepository(Battery::class)->findBy(['sap_code' => $warr_sap_code]);
                                                    if ($batteries == null)
                                                    {
                                                        $no_saps[] = [
                                                            'warranty_id' => $warranty_date_fulfilled->getID(),
                                                            'plate_number' => $cleaned_plate_number,
                                                            'sap_code' => $warr_sap_code,
                                                        ];
                                                    }
                                                }
                                            }

                                            // wrong expiration date
                                            $date_expiry_wrongs[] = [
                                                'warranty_id' => $warranty_date_fulfilled->getID(),
                                                'plate_number' => $cleaned_plate_number,
                                                'expiry_date' => $expiry_date_date_create->format('Y-m-d'),
                                            ];
                                        }
                                    }
                                }
                            }

                            if ($missing_flag)
                            {
                                $missings[] = [
                                    'jo_id' => $jo->getID(),
                                    'plate_number' => $cleaned_plate_number,
                                    'expiry_date' => $expiry_date_date_create->format('Y-m-d'),
                                ];
                            }
                        }
                        else
                        {
                            foreach ($results_date_create as $warranty_date_create)
                            {
                                // check if sap_code exists in battery
                                $warr_sap_battery = $warranty_date_create->getSAPBattery();
                                if ($warr_sap_battery != null)
                                {
                                    $warr_sap_code = $warr_sap_battery->getID();
                                    if ($warr_sap_code != null)
                                    {
                                        $batteries = $em->getRepository(Battery::class)->findBy(['sap_code' => $warr_sap_code]);
                                        if ($batteries == null)
                                        {
                                            $no_saps[] = [
                                                'warranty_id' => $warranty_date_create->getID(),
                                                'plate_number' => $cleaned_plate_number,
                                                'sap_code' => $warr_sap_code,
                                            ];
                                        }
                                    }
                                }

                                $exp_date = '';

                                // check if expiry date is null
                                if ($warranty_date_create->getDateExpire() == null)
                                {
                                    $no_expiries[] = [
                                        'warranty_id' => $warranty_date_create->getID(),
                                        'plate_number' => $cleaned_plate_number,
                                    ];
                                }
                                else
                                {
                                    // check if warranty's expiry date == supposed to be expiry date
                                    $jo_warranty_class = $jo->getWarrantyClass();

                                    $warr_period = $this->getWarrantyPeriod($jo_warranty_class, $invoice_item);

                                    if ($warr_period != -1)
                                    {
                                        $correct_expiry_date = $this->wh->computeDateExpire($warranty_date_create->getDatePurchase(), $warr_period);
                                        $warranty_expiry_date = $warranty_date_create->getDateExpire();

                                        $correct_exp_date = $correct_expiry_date->format('Y-m-d');
                                        $warr_exp_date = $warranty_expiry_date->format('Y-m-d');

                                        if ($correct_exp_date != $warr_exp_date)
                                        {
                                            $comm_privates[] = [
                                                'warranty_id' => $warranty_date_create->getID(),
                                                'plate_number' => $cleaned_plate_number,
                                                'expiry_date' => $warr_exp_date,
                                                'supposed_expiry_date' => $correct_exp_date,
                                            ];
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            $em->detach($row[0]);
            $em->clear();
        }

        $res = [
            'missing' => $missings,
            'invalid_plate_number' => $invalids,
            'commercial_private' => $comm_privates,
            'wrong_expiry_date' => $date_expiry_wrongs,
            'no_expiry_date' => $no_expiries,
            'no_sap_battery' => $no_saps,
        ];

        return $res;

    }

    protected function getDuplicateWarranties($start_date, $end_date)
    {
    }

    protected function outputResults($start_date, $end_date, $missing, $invalid, $commercial_private,
                                     $expiry_wrong, $no_expiry, $no_sap, $duplicate)
    {
        $date_range = $start_date . '-' . $end_date;

        // output one file per array in csv format
        // missing warranties
        // we output the JOs with no warranties
        $missing_csv_filename = $date_range . '-' . 'missing_warranties.csv';
        try
        {
            $missing_fh = fopen($missing_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $missing_csv_filename . '" could not be opened.');
        }

        if ((count($missing)) > 0)
        {
            fputcsv($missing_fh, [
                'JO ID',
                'Plate Number',
                'Expiry Date',
            ]);
 
            foreach($missing as $missing_row)
            {
                fputcsv($missing_fh, $missing_row);
            }
        }

        // invalid plate numbers
        $invalid_plates_csv_filename = $date_range . '-' . 'invalid_plate_jos.csv';
        try
        {
            $invalid_plates_fh = fopen($invalid_plates_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $invalid_plates_csv_filename . '" could not be opened.');
        }

        if ((count($invalid)) > 0)
        {
            fputcsv($invalid_plates_fh, [
                'JO ID',
                'Plate Number',
                'Expiry Date',
            ]);

            foreach($invalid as $invalid_row)
            {
                fputcsv($invalid_plates_fh, $invalid_row);
            }
        }

        // warranties whose expiration dates were set to the commercial period
        // but warranty class is private
        $comm_private_csv_filename = $date_range . '-' . 'comm_private_warranties.csv';
        try
        {
            $comm_private_fh = fopen($comm_private_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $comm_private_csv_filename . '" could not be opened.');
        }

        if ((count($commercial_private)) > 0)
        {
            fputcsv($comm_private_fh, [
                'Warranty ID',
                'Plate Number',
                'Warranty Expiry Date',
                'Correct Expiry Date',
            ]);

            foreach($commercial_private as $comm_private_row)
            {
                fputcsv($comm_private_fh, $comm_private_row);
            }
        }

        // start of expiry date computation is not date_create of invoice
        $expiry_wrong_csv_filename = $date_range . '-' . 'expiry_wrong_warranties.csv';
        try
        {
            $expiry_wrong_fh = fopen($expiry_wrong_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $expiry_wrong_csv_filename . '" could not be opened.');
        }

        if ((count($expiry_wrong)) > 0)
        {
            fputcsv($expiry_wrong_fh, [
                'Warranty ID',
                'Plate Number',
                'Expiry Date',
            ]);

            foreach($expiry_wrong as $expiry_wrong_row)
            {
                fputcsv($expiry_wrong_fh, $expiry_wrong_row);
            }
        }

        // warranties with null in date_expire
        $no_expiry_csv_filename = $date_range . '-' . 'no_expiry_date_warranties.csv';
        try
        {
            $no_expiry_fh = fopen($no_expiry_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $no_expiry_csv_filename . '" could not be opened.');
        }

        if ((count($no_expiry)) > 0)
        {
            fputcsv($no_expiry_fh, [
                'Warranty ID',
                'Plate Number',
            ]);

            foreach($no_expiry as $no_expiry_row)
            {
                fputcsv($no_expiry_fh, $no_expiry_row);
            }
        }

        // sap batteries not in system
        $no_sap_csv_filename = $date_range . '-' . 'no_sap_battery.csv';
        try
        {
            $no_sap_fh = fopen($no_sap_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $no_sap_csv_filename . '" could not be opened.');
        }

        if ((count($no_sap)) > 0)
        {
            fputcsv($no_sap_fh, [
                'Warranty ID',
                'Plate Number',
                'SAP Battery Code',
            ]);

            foreach($no_sap as $no_sap_row)
            {
                fputcsv($no_sap_fh, $no_sap_row);
            }
        }

        // duplicate warranties
        $duplicate_csv_filename = $date_range . '-' . 'duplicate_warranties.csv';
        try
        {
            $duplicate_fh = fopen($duplicate_csv_filename, 'a');
        }
        catch (Exception $e)
        {
            throw new Exception('The file "' . $duplicate_csv_filename . '" could not be opened.');
        }

        if ((count($duplicate)) > 0)
        {
            fputcsv($duplicate_fh, [
                'Warranty ID',
                'Plate Number',
                'Expiry Date',
            ]);

            foreach($duplicate as $duplicate_row)
            {
                fputcsv($duplicate_fh, $duplicate_row);
            }
        }
    }

    protected function loadSAPBatteries()
    {
        $this->sapbatt_hash = [];

        $sap_batteries = $this->em->getRepository(SAPBattery::class)->findAll();
        foreach($sap_batteries as $sap_batt)
        {
            $id = $sap_batt->getID();
            $brand_size = $sap_batt->getBrand()->getID() . " " .  $sap_batt->getSize()->getID();
            $this->sapbatt_hash[$id] = $brand_size;
        }
    }

    protected function findSAPBattery($batt_id)
    {
        if (!isset($this->sapbatt_hash[$batt_id]))
        {
            return false;
        }

        return true;
    }

    protected function getWarrantyPeriod($warranty_class, InvoiceItem $invoice_item)
    {
        $warr_period = -1;
        if ($warranty_class == WarrantyClass::WTY_PRIVATE)
        {
            $warr_period = $invoice_item->getBattery()->getWarrantyPrivate();
        }
        if ($warranty_class == WarrantyClass::WTY_COMMERCIAL)
        {
            $warr_period = $invoice_item->getBattery()->getWarrantyCommercial();
        }
        if ($warranty_class == WarrantyClass::WTY_TNV)
        {
            $warr_period = $invoice_item->getBattery()->getWarrantyTnv();
        }

        return $warr_period;

    }
}