<?php

namespace common\manager;

use common\models\Card;
use common\models\Customer;
use common\models\Event;
use common\models\EventRegistration;
use common\models\Ticket;
use yii\db\Query;
use yii\web\BadRequestHttpException;
use yii\web\NotFoundHttpException;
use yii\web\ServerErrorHttpException;

/**
 * Created by IntelliJ IDEA.
 * User: rocho
 * Date: 2018.12.17.
 * Time: 6:12
 */
class EventRegistrationManager extends \yii\base\Object
{
    const CARD_NOT_FOUND = 1;
    const CUSTOMER_NOT_FOUND = 2;
    const TICKET_NOT_FOUND = 3;
    const NO_FREE_SEATS = 4;
    const EVENT_TYPE_NOT_FOUND = 5;
    const TICKET_INSUFFICIENT = 6;
    const UNKNOWN_ERROR = 7;
    const MAX_SEAT_COUNT_EXCEEDED = 8;
    const EVENT_UNAVAILABLE = 9;

    public static $STATES = [
        self::CARD_NOT_FOUND => "CARD_NOT_FOUND",
        self::CUSTOMER_NOT_FOUND => "CUSTOMER_NOT_FOUND",
        self::TICKET_NOT_FOUND => "TICKET_NOT_FOUND",
        self::NO_FREE_SEATS => "NO_FREE_SEATS",
        self::EVENT_TYPE_NOT_FOUND => "EVENT_TYPE_NOT_FOUND",
        self::TICKET_INSUFFICIENT => "TICKET_INSUFFICIENT",
        self::UNKNOWN_ERROR => "UNKNOWN_ERROR",
        self::MAX_SEAT_COUNT_EXCEEDED => "MAX_SEAT_COUNT_EXCEEDED",
        self::EVENT_UNAVAILABLE => "EVENT_UNAVAILABLE",


    ];

    /**
     * @param \common\models\CardEventRegistrationForm $cardEventForm
     * @throws \yii\db\Exception
     */
    public function registerCard($cardEventForm)
    {
        $db = \Yii::$app->db;
        $tx = $db->beginTransaction();
        try {
            if ($cardEventForm->validate()) {

                /** @var \common\models\Card $card */
                $card = Card::readCard($cardEventForm->card_number, false);
                if (!isset($card)) {
                    throw new NotFoundHttpException("Card not found: " . $cardEventForm->card_number, self::CARD_NOT_FOUND);
                }

                if ($card->isFree()) {
                    throw new NotFoundHttpException("Customer not found", self::CUSTOMER_NOT_FOUND);
                }

                $activeTickets = $card->getActiveTickets();
                if (sizeof($activeTickets) == 0) {
                    throw new NotFoundHttpException("Ticket not found", self::TICKET_NOT_FOUND);
                }

                /** @var \common\models\Event $event */
                $event = Event::find()->andWhere(['id' => $cardEventForm->event_id])->one();
                if (!isset($event)) {
                    throw new NotFoundHttpException("Event not found: " . $cardEventForm->event_id);
                }

                if ( isset($event->deleted_at)){
                    throw new BadRequestHttpException("Event deleted", self::EVENT_UNAVAILABLE);
                }

                if (!$event->hasFreeSeats()) {
                    throw new BadRequestHttpException("No free seats", self::NO_FREE_SEATS);
                }

                $eventType = $event->eventType;

                if (!isset($eventType)) {
                    throw new ServerErrorHttpException("Event type not found", self::EVENT_TYPE_NOT_FOUND);
                }

                $selectedTicket = $eventType->findTicketAllowingEventType($activeTickets);


                if (!isset($selectedTicket)) {
                    throw new NotFoundHttpException("Ticket not found", self::TICKET_INSUFFICIENT);
                }

                if ($selectedTicket->hasOpenReservationCount()) {
                    $selectedTicket->consumeReservationCount(1);
                }
                $selectedTicket->save();

                $registration = new EventRegistration();
                $registration->id_event = $event->id;
                $registration->id_card = $card->id_card;
                $registration->id_ticket = $selectedTicket->id_ticket;
                try {
                    $registration->save(false);
                } catch (\Throwable $exception) {
                    throw new ServerErrorHttpException("Failed to save", self::UNKNOWN_ERROR);
                }

                $cardEventForm->registration = $registration;
            }
            $tx->commit();
        } catch (\Exception $exception) {
            $tx->rollBack();
        }

    }

    public function createFindRegistrationsQuery($idEvent)
    {
        $query = new Query();
        $query->select([
            "event_registration.id as event_registration_id",
            "event_registration.created_at as event_registration_created_at",
            "event_registration.canceled_at as event_registration_canceled_at",
            "event_registration.deleted_at as event_registration_deleted_at",
            "card.id_card as card_id_card",
            "card.number as card_number",
            "customer.id_customer as customer_id_customer",
            "customer.name as customer_name",
            "customer.email as customer_email",
        ]);
        $query->from(EventRegistration::tableName());
        $query->innerJoin(Event::tableName(), "event_registration.id_event = event.id");
        $query->innerJoin(Card::tableName(), "event_registration.id_card = card.id_card");
        $query->innerJoin(Customer::tableName(), "customer.id_customer_card = card.id_card");
        $query->andWhere(["event_registration.id_event" => $idEvent]);

        return $query;
    }


    /**
     * @param $idRegistration
     * @return array|EventRegistration|\yii\db\ActiveRecord|null
     * @throws NotFoundHttpException
     */
    public function loadRegistration($idRegistration)
    {

        $registration = EventRegistration::find()->andWhere(['id' => $idRegistration])->one();
        if ($registration == null) {
            throw new NotFoundHttpException('The requested registration does not exist.');
        }
        return $registration;
    }

    /**
     * @param \common\models\EventRegistration $registration
     * @throws ServerErrorHttpException
     */
    public function cancelRegistration($registration)
    {
        if (isset($registration->canceled_at)) {
            throw new ServerErrorHttpException('The registration is already canceled');
        }

        if (isset($registration->deleted_at)) {
            throw new ServerErrorHttpException('The reservation is already deleted');
        }

        $registration->canceled_at = date('Y-m-d H:i:s');
        $registration->save(false);

    }

    /**
     * @param \common\models\EventRegistration $registration
     * @throws ServerErrorHttpException
     */
    public function deleteRegistration($registration)
    {
        if (isset($registration->deleted_at)) {
            throw new ServerErrorHttpException('The reservation is already deleted');
        }

        $ticket = Ticket::findOne(['id_ticket' => $registration->id_ticket]);

        $ticket->restoreReservationCount(1);
        $ticket->save(false);

        $registration->deleted_at = date('Y-m-d H:i:s');
        $registration->save(false);

    }

    /**
     * Delete an event
     * @param \common\models\Event $event
     * @throws \yii\db\Exception
     * @throws \Exception
     */
    public function deleteEvent($event)
    {
        $db = \Yii::$app->db;
        $tx = $db->beginTransaction();
        try {

            $registrations = $event->getEventRegistrations()->all();
            // ////////////////////////////////
            // if even has no registrations
            // we can simply delete it from db
            // ////////////////////////////////
            if (count($registrations) == 0) {
                $event->delete();
            } else {
                $event->deleted_at = date('Y-m-d H:i:s');
                $event->save(false);
                foreach ($registrations as $registration) {
                    if (!isset($registration->deleted_at)) {
                        /** @var \common\models\EventRegistration $registration */
                        $this->deleteRegistration($registration);
                    }
                }
            }
            $tx->commit();
        } catch (\Exception $e) {
            $tx->rollBack();
            throw $e;
        }

    }


}