<?php namespace MapGuesser\Controller;

use DateTime;
use MapGuesser\Interfaces\Authorization\ISecured;
use MapGuesser\Interfaces\Request\IRequest;
use MapGuesser\Util\Geo\Position;
use MapGuesser\Response\JsonContent;
use MapGuesser\Interfaces\Response\IContent;
use MapGuesser\Multi\MultiConnector;
use MapGuesser\PersistentData\PersistentDataManager;
use MapGuesser\PersistentData\Model\Challenge;
use MapGuesser\PersistentData\Model\Guess;
use MapGuesser\PersistentData\Model\Map;
use MapGuesser\PersistentData\Model\Place;
use MapGuesser\PersistentData\Model\PlaceInChallenge;
use MapGuesser\PersistentData\Model\User;
use MapGuesser\PersistentData\Model\UserPlayedPlace;
use MapGuesser\Repository\ChallengeRepository;
use MapGuesser\Repository\GuessRepository;
use MapGuesser\Repository\MapRepository;
use MapGuesser\Repository\MultiRoomRepository;
use MapGuesser\Repository\PlaceInChallengeRepository;
use MapGuesser\Repository\PlaceRepository;
use MapGuesser\Repository\UserInChallengeRepository;
use MapGuesser\Repository\UserPlayedPlaceRepository;
use MapGuesser\Repository\UserRepository;

class GameFlowController implements ISecured
{
    const NUMBER_OF_ROUNDS = 5;
    const MAX_SCORE = 1000;

    private IRequest $request;

    private PersistentDataManager $pdm;

    private MultiConnector $multiConnector;

    private MultiRoomRepository $multiRoomRepository;

    private PlaceRepository $placeRepository;

    private MapRepository $mapRepository;

    private UserRepository $userRepository;

    private UserPlayedPlaceRepository $userPlayedPlaceRepository;

    private ChallengeRepository $challengeRepository;

    private UserInChallengeRepository $userInChallengeRepository;

    private PlaceInChallengeRepository $placeInChallengeRepository;

    private GuessRepository $guessRepository;

    public function __construct(IRequest $request)
    {
        $this->request = $request;
        $this->pdm = new PersistentDataManager();
        $this->multiConnector = new MultiConnector();
        $this->multiRoomRepository = new MultiRoomRepository();
        $this->placeRepository = new PlaceRepository();
        $this->mapRepository = new MapRepository();
        $this->userRepository = new UserRepository();
        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
        $this->challengeRepository = new ChallengeRepository();
        $this->userInChallengeRepository = new UserInChallengeRepository();
        $this->placeInChallengeRepository = new PlaceInChallengeRepository();
        $this->guessRepository = new GuessRepository();
    }

    public function authorize(): bool
    {
        return !empty($_ENV['ENABLE_GAME_FOR_GUESTS']) || $this->request->user() !== null;
    }

    public function initialData(): IContent
    {
        $mapId = (int) $this->request->query('mapId');
        $session = $this->request->session();

        if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
            return new JsonContent(['error' => 'no_session_found']);
        }

        if (!isset($state['currentRound']) || $state['currentRound'] == -1 || $state['currentRound'] >= static::NUMBER_OF_ROUNDS) {
            $this->startNewGame($state, $mapId);
            $session->set('state', $state);
        }

        $response = [];

        $last = $state['rounds'][$state['currentRound']];
        $response['place'] = [
            'panoId' => $last['panoId'],
            'pov' => $last['pov']->toArray()
        ];

        $response['history'] = [];
        for ($i = 0; $i < $state['currentRound']; ++$i) {
            $round = $state['rounds'][$i];
            $response['history'][] = [
                'position' => $round['position']->toArray(),
                'result' => [
                    'guessPosition' => $round['guessPosition']->toArray(),
                    'distance' => $round['distance'],
                    'score' => $round['score']
                ]
            ];
        }

        return new JsonContent($response);
    }

    public function multiInitialData(): IContent
    {
        $roomId = $this->request->query('roomId');
        $session = $this->request->session();

        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
            return new JsonContent(['error' => 'no_session_found']);
        }

        $room = $this->multiRoomRepository->getByRoomId($roomId);
        $state = $room->getStateArray();
        $members = $room->getMembersArray();

        if ($members['owner'] !== $multiState['token']) {
            return new JsonContent(['error' => 'not_owner_of_room']);
        }

        if ($state['currentRound'] == -1 || $state['currentRound'] >= static::NUMBER_OF_ROUNDS - 1) {
            $this->startNewGame($state, $state['mapId']);
            $room->setStateArray($state);
            $room->setUpdatedDate(new DateTime());
            $this->pdm->saveToDb($room);
        }

        $places = [];
        foreach ($state['rounds'] as $round) {
            $places[] = [
                'position' => $round['position']->toArray(),
                'panoId' => $round['panoId'],
                'pov' => $round['pov']->toArray()
            ];
        }

        $this->multiConnector->sendMessage('start_game', ['roomId' => $roomId, 'places' => $places]);

        return new JsonContent(['ok' => true]);
    }

    private function prepareChallengeResponse(int $userId, Challenge $challenge, int $currentRound, bool $withHistory = false): array
    {
        $currentPlace = $this->placeRepository->getByRoundInChallenge($challenge, $currentRound);
        
        // if the last round was played ($currentPlace == null) or history is explicitly requested (for initializing)
        if (!isset($currentPlace) || $withHistory) {

            $withRelations = [User::class, PlaceInChallenge::class, Place::class];
            foreach ($this->guessRepository->getAllInChallenge($challenge, $withRelations) as $guess) { 
                $round = $guess->getPlaceInChallenge()->getRound();
    
                if ($guess->getUser()->getId() === $userId) {
                    $response['history'][$round]['position'] = 
                            $guess->getPlaceInChallenge()->getPlace()->getPosition()->toArray();
                    $response['history'][$round]['result'] = [
                            'guessPosition' => $guess->getPosition()->toArray(),
                            'distance' => $guess->getDistance(),
                            'score' => $guess->getScore()
                    ];
                } else {
                    $response['history'][$round]['allResults'][] = [
                        'userName' => $guess->getUser()->getDisplayName(),
                        'guessPosition' => $guess->getPosition()->toArray(),
                        'distance' => $guess->getDistance(),
                        'score' => $guess->getScore()
                    ];
                }
            }

            // setting default values for rounds without guesses (because of timeout)
            for ($i = 0; $i < $currentRound; ++$i) {
                if (!isset($response['history'][$i]) || !isset($response['history'][$i]['result'])) {
                    $response['history'][$i]['result'] = [
                            'guessPosition' => null,
                            'distance' => null,
                            'score' => 0
                    ];
                    
                    $response['history'][$i]['position'] = 
                            $this->placeRepository->getByRoundInChallenge($challenge, $i)->getPosition()->toArray();
                }
            }

            $response['history']['length'] = $currentRound;
        }

        if (!isset($currentPlace)) { // game finished
            $response['finished'] = true;
        } else { // continue game
            $response['place'] = [
                'panoId' => $currentPlace->getPanoIdCached(),
                'pov' => $currentPlace->getPov()->toArray()
            ];

            $prevRound = $currentRound - 1;
            if ($prevRound >= 0) {
                foreach ($this->guessRepository->getAllInChallengeByRound($prevRound, $challenge, [User::class]) as $guess) {
                    if ($guess->getUser()->getId() != $userId) {
                        $response['allResults'][] = [
                            'userName' => $guess->getUser()->getDisplayName(),
                            'guessPosition' => $guess->getPosition()->toArray(),
                            'distance' => $guess->getDistance(),
                            'score' => $guess->getScore()
                        ];
                    }
                }
            }
        }

        $response['restrictions'] = [
            'timeLimit' => $challenge->getTimeLimit() * 1000,
            'timeLimitType' => $challenge->getTimeLimitType(),
            'noMove' => $challenge->getNoMove(),
            'noPan' => $challenge->getNoPan(),
            'noZoom' => $challenge->getNoZoom()
        ];

        return $response;
    }

    public function challengeInitialData(): IContent
    {
        $session = $this->request->session();
        $userId = $session->get('userId');
        $challengeToken_str = $this->request->query('challengeToken');
        $userInChallenge = $this->userInChallengeRepository->getByUserIdAndToken($userId, $challengeToken_str, [Challenge::class]);

        if (!isset($userInChallenge)) {
            return new JsonContent(['error' => 'game_not_found']);
        }

        $challenge = $userInChallenge->getChallenge();
        $currentRound = $userInChallenge->getCurrentRound();

        $response = $this->prepareChallengeResponse($userId, $challenge, $currentRound, true);

        if ($challenge->getTimeLimitType() === 'game' && $challenge->getTimeLimit() !== null && $userInChallenge->getCurrentRound() > 0) {
            $timeLimit = max(10, $userInChallenge->getTimeLeft());
            $response['restrictions']['timeLimit'] = $timeLimit * 1000;
        } 

        return new JsonContent($response);
    }

    public function guess(): IContent
    {
        $mapId = (int) $this->request->query('mapId');
        $session = $this->request->session();

        if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
            return new JsonContent(['error' => 'no_session_found']);
        }

        $last = $state['rounds'][$state['currentRound']];
        $guessPosition = new Position((float) $this->request->post('lat'), (float) $this->request->post('lng'));
        $result = $this->evaluateGuess($last['position'], $guessPosition, $state['area']);

        $last['guessPosition'] = $guessPosition;
        $last['distance'] = $result['distance'];
        $last['score'] = $result['score'];

        $response = [
            'position' => $last['position']->toArray(),
            'result' => $result
        ];

        $state['rounds'][$state['currentRound']] = $last;
        $state['currentRound'] += 1;
        if ($state['currentRound'] < static::NUMBER_OF_ROUNDS) {
            $next = $state['rounds'][$state['currentRound']];

            $response['place'] = [
                'panoId' => $next['panoId'],
                'pov' => $next['pov']->toArray()
            ];
        }

        $session->set('state', $state);

        $this->saveVisit($last['placeId']);

        return new JsonContent($response);
    }

    // save the selected place for the round in UserPlayedPlace
    private function saveVisit($placeId): void
    {
        $session = $this->request->session();
        $userId = $session->get('userId');

        if (isset($userId)) {
            $userPlayedPlace = $this->userPlayedPlaceRepository->getByUserIdAndPlaceId($userId, $placeId);
            if (!$userPlayedPlace) {
                $userPlayedPlace = new UserPlayedPlace();
                $userPlayedPlace->setUserId($userId);
                $userPlayedPlace->setPlaceId($placeId);
            } else {
                $userPlayedPlace->incrementOccurrences();
            }
            $userPlayedPlace->setLastTimeDate(new DateTime());
            $this->pdm->saveToDb($userPlayedPlace);
        }
    }

    public function multiGuess(): IContent
    {
        $roomId = $this->request->query('roomId');
        $session = $this->request->session();

        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
            return new JsonContent(['error' => 'no_session_found']);
        }

        $room = $this->multiRoomRepository->getByRoomId($roomId);
        $state = $room->getStateArray();

        $last = $state['rounds'][$state['currentRound']];
        $guessPosition = new Position((float) $this->request->post('lat'), (float) $this->request->post('lng'));
        $result = $this->evaluateGuess($last['position'], $guessPosition, $state['area']);

        $responseFromMulti = $this->multiConnector->sendMessage('guess', [
            'roomId' => $roomId,
            'token' => $multiState['token'],
            'guessPosition' => $guessPosition->toArray(),
            'distance' => $result['distance'],
            'score' => $result['score']
        ]);

        if (isset($responseFromMulti['error'])) {
            return new JsonContent(['error' => $responseFromMulti['error']]);
        }

        $response = [
            'position' => $last['position']->toArray(),
            'result' => $result,
            'allResults' => $responseFromMulti['allResults']
        ];

        return new JsonContent($response);
    }

    public function challengeGuess(): IContent
    {
        $session = $this->request->session();
        $userId = $session->get('userId');
        $challengeToken_str = $this->request->query('challengeToken');
        $userInChallenge = $this->userInChallengeRepository->getByUserIdAndToken($userId, $challengeToken_str, [Challenge::class]);

        if (!isset($userInChallenge)) {
            return new JsonContent(['error' => 'game_not_found']);
        }

        $challenge = $userInChallenge->getChallenge();
        $currentRound = $userInChallenge->getCurrentRound();
        $currentPlaceInChallenge = $this->placeInChallengeRepository->getByRoundInChallenge($currentRound, $challenge, [Place::class, Map::class]);
        $currentPlace = $currentPlaceInChallenge->getPlace();
        $map = $currentPlace->getMap();

        // creating response
        $nextRound = $currentRound + 1;
        $response = $this->prepareChallengeResponse($userId, $challenge, $nextRound);
        $response['position'] = $currentPlace->getPosition()->toArray();

        if ($this->request->post('lat') && $this->request->post('lng')) {
            $guessPosition = new Position((float) $this->request->post('lat'), (float) $this->request->post('lng'));
            $result = $this->evaluateGuess($currentPlace->getPosition(), $guessPosition, $map->getArea());

            // save guess
            $guess = new Guess();
            $guess->setUserId($userId);
            $guess->setPlaceInChallenge($currentPlaceInChallenge);
            $guess->setPosition($guessPosition);
            $guess->setDistance($result['distance']);
            $guess->setScore($result['score']);
            $this->pdm->saveToDb($guess);

            $response['result'] = $result;

        } else {
            // user didn't manage to guess in the round in the given timeframe
            $response['result'] = ['distance' => null, 'score' => 0];
        }

        // save user relevant state of challenge
        $userInChallenge->setCurrentRound($nextRound);
        $timeLeft = $this->request->post('timeLeft');
        if (isset($timeLeft)) {
            $userInChallenge->setTimeLeft(intval($timeLeft));
        }
        $this->pdm->saveToDb($userInChallenge);

        if ($challenge->getTimeLimitType() === 'game' && isset($timeLeft)) {
            $timeLimit = max(10, intval($timeLeft));
            $response['restrictions']['timeLimit'] = $timeLimit * 1000;
        }

        if (isset($response['history'][$currentRound]['allResults'])) {
            $response['allResults'] = $response['history'][$currentRound]['allResults'];
        }

        $this->saveVisit($currentPlace->getId());

        return new JsonContent($response);
    }

    public function multiNextRound(): IContent
    {
        $roomId = $this->request->query('roomId');
        $session = $this->request->session();

        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
            return new JsonContent(['error' => 'no_session_found']);
        }

        $room = $this->multiRoomRepository->getByRoomId($roomId);
        $state = $room->getStateArray();
        $members = $room->getMembersArray();

        if ($members['owner'] !== $multiState['token']) {
            return new JsonContent(['error' => 'not_owner_of_room']);
        }

        $state['currentRound'] += 1;
        if ($state['currentRound'] < static::NUMBER_OF_ROUNDS) {
            $this->multiConnector->sendMessage('next_round', ['roomId' => $roomId, 'currentRound' => $state['currentRound']]);
        }

        $room->setStateArray($state);
        $room->setUpdatedDate(new DateTime());
        $this->pdm->saveToDb($room);

        return new JsonContent(['ok' => true]);
    }

    private function evaluateGuess(Position $realPosition, Position $guessPosition, float $area)
    {
        $distance = $this->calculateDistance($realPosition, $guessPosition);
        $score = $this->calculateScore($distance, $area);

        return ['distance' => $distance, 'score' => $score];
    }

    private function startNewGame(array &$state, int $mapId): void
    {
        $session = $this->request->session();
        $userId = $session->get('userId');

        $places = $this->placeRepository->getRandomNPlaces($mapId, static::NUMBER_OF_ROUNDS, $userId);

        $state['rounds'] = [];
        $state['currentRound'] = 0;

        foreach ($places as $place) {
            $state['rounds'][] = [
                'placeId' => $place->getId(),
                'position' => $place->getPosition(),
                'panoId' => $place->getPanoIdCached(),
                'pov' => $place->getPov()
            ];
        }
    }

    private function calculateDistance(Position $realPosition, Position $guessPosition): float
    {
        return $realPosition->calculateDistanceTo($guessPosition);
    }

    private function calculateScore(float $distance, float $area): int
    {
        $goodness = 1.0 - ($distance / (sqrt($area) * 1000));

        return (int) round(pow(static::MAX_SCORE, $goodness));
    }
}