<?php

namespace App\Service\CustomerHandler;

use Doctrine\ORM\EntityManagerInterface;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Validator\Validator\ValidatorInterface;

use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

use App\Service\CustomerHandlerInterface;

use App\Ramcar\CustomerClassification;
use App\Ramcar\FuelType;
use App\Ramcar\VehicleStatusCondition;
use App\Ramcar\CrudException;

use App\Entity\Customer;
use App\Entity\CustomerVehicle;
use App\Entity\Vehicle;
use App\Entity\Battery;
use App\Entity\VehicleManufacturer;
use App\Entity\BatteryManufacturer;

use DateTime;

class ResqCustomerHandler implements CustomerHandlerInterface
{
    protected $em;
    protected $validator;

    protected $template_hash;

    public function __construct(EntityManagerInterface $em, ValidatorInterface $validator)
    {
        $this->em = $em;
        $this->validator = $validator;

        $this->loadTemplates();
    }

    // initialize form to display customer list
    public function initializeCustomerIndexForm()
    {
        $params['template'] = $this->getTwigTemplate('cust_list');

        return $params;
    }

    // initialize add customer form
    public function initializeAddCustomerForm()
    {
        $params['obj'] = new Customer();
        $params['mode'] = 'create';

        // get dropdown parameters
        $this->fillDropdownParameters($params);

        // get template to display
        $params['template'] = $this->getTwigTemplate('cust_add_form');

        // return params
        return $params;
    }


    // add new customer and customer vehicle, if any
    public function addCustomer(Request $req)
    {
        // create new row
        $em = $this->em;
        $row = new Customer();

        $this->setObject($row, $req);

        // initialize error lists
        $error_array = [];
        $nerror_array = [];
        $verror_array = [];

        // custom validation for vehicles
        $vehicles = json_decode($req->request->get('vehicles'));

        if (!empty($vehicles)) 
        {
            foreach ($vehicles as $vehicle) 
            {
                // check if vehicle exists
                $vobj = $em->getRepository(Vehicle::class)->find($vehicle->vehicle);

                if (empty($vobj)) 
                {
                    $verror_array[$vehicle->index]['vehicle'] = 'Invalid vehicle specified.';
                } 
                else 
                {
                    $cust_vehicle = new CustomerVehicle();
                    $cust_vehicle->setName($vehicle->name)
                        ->setVehicle($vobj)
                        ->setPlateNumber($vehicle->plate_number)
                        ->setModelYear($vehicle->model_year)
                        ->setColor($vehicle->color)
                        ->setStatusCondition($vehicle->status_condition)
                        ->setFuelType($vehicle->fuel_type)
                        ->setActive($vehicle->flag_active)
                        ->setCustomer($row);

                    // if specified, check if battery exists
                    if ($vehicle->battery) 
                    {
                        // check if battery exists
                        $bobj = $em->getRepository(Battery::class)->find($vehicle->battery);

                        if (empty($bobj)) 
                        {
                            $verror_array[$vehicle->index]['battery'] = 'Invalid battery specified.';
                        } 
                        else 
                        {
                            // check if warranty expiration was specified
                            $warr_ex = DateTime::createFromFormat("d M Y", $vehicle->warranty_expiration);
                            if (!$warr_ex)
                                $warr_ex = null;

                            $cust_vehicle->setHasMotoliteBattery(true)
                                ->setCurrentBattery($bobj)
                                ->setWarrantyCode($vehicle->warranty_code)
                                ->setWarrantyExpiration($warr_ex);
                        }
                    } 
                    else 
                    {
                         $cust_vehicle->setHasMotoliteBattery(false);
                    }

                    $verrors = $this->validator->validate($cust_vehicle);

                    // add errors to list
                    foreach ($verrors as $error) 
                    {
                        if (!isset($verror_array[$vehicle->index]))
                            $verror_array[$vehicle->index] = [];

                        $verror_array[$vehicle->index][$error->getPropertyPath()] = $error->getMessage();
                    }

                    // add to entity
                    if (!isset($verror_array[$vehicle->index])) 
                    {
                        $row->addVehicle($cust_vehicle);
                    }
                }
            }
        }

        // validate
        $errors = $this->validator->validate($row);

        // add errors to list
        foreach ($errors as $error) 
        {
            $error_array[$error->getPropertyPath()] = $error->getMessage();
        }

        // check if any errors were found
        if (!empty($error_array) || !empty($nerror_array) || !empty($verror_array)) 
        {
            // return all error_arrays
            $result = [
                'error_array' => $error_array,
                'nerror_array' => $nerror_array,
                'verror_array' => $verror_array,
            ];
        } 
        else 
        {
            // validated! save the entity
            $em->persist($row);
            $em->flush();

            $result = [
                'id' => $row->getID(),
            ];
        }

        return $result;
    }

    // initialize update customer form
    public function initializeUpdateCustomerForm($id)
    {
        $params['mode'] = 'update';

        // get row data
        $em = $this->em;
        $row = $em->getRepository(Customer::class)->find($id);

        // make sure this row exists
        if (empty($row))
            throw new NotFoundHttpException('The item does not exist');

        // get dropdown parameters
        $this->fillDropdownParameters($params);

        // get template to display
        $params['template'] = $this->getTwigTemplate('cust_update_form');

        $params['obj'] = $row;

        return $params;
    }

    // update customer and customer vehicle
    public function updateCustomer(Request $req, $id)
    {
        // get row data
        $em = $this->em;
        $cust = $em->getRepository(Customer::class)->find($id);

        // make sure this row exists
        if (empty($cust))
            throw $this->createNotFoundException('The item does not exist');

        $this->setObject($cust, $req);

        // initialize error lists
        $error_array = [];
        $nerror_array = [];
        $verror_array = [];

        // TODO: validate mobile numbers
        // TODO: validate vehicles

        // custom validation for vehicles
        $vehicles = json_decode($req->request->get('vehicles'));
        $this->updateVehicles($em, $cust, $vehicles);

        // validate
        $errors = $this->validator->validate($cust);

        // add errors to list
        foreach ($errors as $error)
        {
            $error_array[$error->getPropertyPath()] = $error->getMessage();
        }

        // check if any errors were found
        if (!empty($error_array) || !empty($nerror_array) || !empty($verror_array))
        {
            // return all error_arrays
            $result = [
                'error_array' => $error_array,
                'nerror_array' => $nerror_array,
                'verror_array' => $verror_array,
            ];

        }
        else
        {
            // validated! save the entity. do a persist anyway to save child entities
            $em->persist($cust);
            $em->flush();

            $result = [
                'id' => $cust->getID(),
            ];
        }

        return $result;
    }

    public function getTwigTemplate($id)
    {
        if (isset($this->template_hash[$id]))
        {
            return $this->template_hash[$id];
        }

        return null;
    }

    protected function setObject($obj, $req)
    {
        // set and save values
        $obj->setTitle($req->request->get('title'))
            ->setFirstName($req->request->get('first_name'))
            ->setLastName($req->request->get('last_name'))
            ->setCustomerClassification($req->request->get('customer_classification'))
            ->setCustomerNotes($req->request->get('customer_notes'))
            ->setEmail($req->request->get('email'))
            ->setIsCSAT($req->request->get('flag_csat') ? true : false)
            ->setActive($req->request->get('flag_active') ? true : false);

        // phone numbers
        $obj->setPhoneMobile($req->request->get('phone_mobile'))
            ->setPhoneLandline($req->request->get('phone_landline'))
            ->setPhoneOffice($req->request->get('phone_office'))
            ->setPhoneFax($req->request->get('phone_fax'));
    }

    protected function fillDropdownParameters(&$params)
    {
        $em = $this->em;

        $params['bmfgs'] = $em->getRepository(BatteryManufacturer::class)->findAll();
        $params['vmfgs'] = $em->getRepository(VehicleManufacturer::class)->findAll();

        $params['classifications'] = CustomerClassification::getCollection();
        $params['fuel_types'] = FuelType::getCollection();
        $params['status_conditions'] = VehicleStatusCondition::getCollection();

        $params['years'] = $this->generateYearOptions();
        $params['batteries'] = $em->getRepository(Battery::class)->findAll();
    }

    protected function generateYearOptions()
    {
        $start_year = 1950;
        return range($start_year, date("Y") + 1);
    }

    protected function loadTemplates()
    {
        $this->template_hash = [];

        // add all twig templates for customer to hash
        $this->template_hash['cust_add_form'] = 'customer/form.html.twig';
        $this->template_hash['cust_update_form'] = 'customer/form.html.twig';
        $this->template_hash['cust_list'] = 'customer/list.html.twig';
    }

    protected function updateVehicles($em, Customer $cust, $vehicles)
    {
        $vehicle_ids = [];

        foreach ($vehicles as $vehicle)
        {
            // check if customer vehicle exists
            if (!empty($vehicle->id))
            {
                $cust_vehicle = $em->getRepository(CustomerVehicle::class)->find($vehicle->id);
                if ($cust_vehicle == null)
                    throw new CrudException("Could not find customer vehicle.");

            }
            // this is a new vehicle
            else
            {
                $cust_vehicle = new CustomerVehicle();
                $cust_vehicle->setCustomer($cust);
                $cust->addVehicle($cust_vehicle);
                $em->persist($cust_vehicle);
            }

            // vehicle, because they could have changed vehicle type
            $vobj = $em->getRepository(Vehicle::class)->find($vehicle->vehicle);
            if ($vobj == null)
                throw new CrudException("Could not find vehicle.");

            // TODO: validate details

            $cust_vehicle->setName($vehicle->name)
                ->setVehicle($vobj)
                ->setPlateNumber($vehicle->plate_number)
                ->setModelYear($vehicle->model_year)
                ->setColor($vehicle->color)
                ->setStatusCondition($vehicle->status_condition)
                ->setFuelType($vehicle->fuel_type)
                ->setActive($vehicle->flag_active);

            // if specified, check if battery exists
            if ($vehicle->battery)
            {
                // check if battery exists
                $bobj = $em->getRepository(Battery::class)->find($vehicle->battery);
                if ($bobj == null)
                    throw new CrudException("Could not find battery.");

                // check if warranty expiration was specified
                $warr_ex = DateTime::createFromFormat("d M Y", $vehicle->warranty_expiration);
                if (!$warr_ex)
                    $warr_ex = null;

                $cust_vehicle->setHasMotoliteBattery(true)
                    ->setCurrentBattery($bobj)
                    ->setWarrantyCode($vehicle->warranty_code)
                    ->setWarrantyExpiration($warr_ex);
            }
            else
            {
                 $cust_vehicle->setHasMotoliteBattery(false);
            }

            // add to list of vehicles to keep
            $vehicle_ids[$cust_vehicle->getID()] = true;
        }

        // cleanup
        // delete all vehicles not in list
        $cvs = $cust->getVehicles();
        foreach ($cvs as $cv)
        {
            if (!isset($vehicle_ids[$cv->getID()]))
            {
                $cust->removeVehicle($cv);
                $em->remove($cv);
            }
        }
    }
}