<?php
  
  namespace FootyRoom\Http\ViewComposers;
  
  use Exception;
  use Illuminate\View\View;
  use FootyRoom\Queries\MatchQuery;
  use FootyRoom\Queries\StageQuery;
  use FootyRoom\Queries\TableQuery;
  use FootyRoom\Core\Match\MatchDays;
  use FootyRoom\Support\Utils\Helpers;
  use FootyRoom\Queries\MatchPostQuery;
  use FootyRoom\Queries\StageGuideQuery;
  use FootyRoom\Queries\StageStatsQuery;
  use Illuminate\Contracts\Cache\Repository;
  
  class CompetitionComposer
  {
      /**
       * @var int
       */
      protected $postPerPage = 24;
  
      /**
       * @var \FootyRoom\Queries\StageGuideQuery
       */
      protected $guideRepo;
  
      /**
       * @var \FootyRoom\Queries\TableQuery
       */
      protected $tableRepo;
  
      /**
       * @var \FootyRoom\Queries\StageQuery
       */
      protected $stageRepo;
  
      /**
       * @var \FootyRoom\Queries\MatchPostQuery
       */
      protected $matchPostQuery;
  
      /**
       * @var \FootyRoom\Queries\StageStatsQuery
       */
      protected $statsRepo;
  
      /**
       * @var \FootyRoom\Queries\MatchQuery
       */
      protected $matchRepo;
  
      /**
       * @var \Illuminate\Contracts\Cache\Repository
       */
      protected $cache;
  
      /**
       * Constructor.
       *
       * @param MatchPostQuery $matchPostQuery
       * @param TableQuery $tableRepo
       * @param StageQuery $stageRepo
       * @param StageStatsQuery $statsRepo
       * @param StageGuideQuery $guideRepo
       * @param MatchQuery $matchRepo
       * @param \Illuminate\Contracts\Cache\Repository $cache
       */
      public function __construct(
          MatchPostQuery $matchPostQuery,
          TableQuery $tableRepo,
          StageQuery $stageRepo,
          StageStatsQuery $statsRepo,
          StageGuideQuery $guideRepo,
          MatchQuery $matchRepo,
          Repository $cache
      ) {
          $this->matchPostQuery = $matchPostQuery;
          $this->tableRepo = $tableRepo;
          $this->stageRepo = $stageRepo;
          $this->guideRepo = $guideRepo;
          $this->statsRepo = $statsRepo;
          $this->matchRepo = $matchRepo;
          $this->cache = $cache;
      }
  
      /**
       * Compose the view.
       *
       * @param \Illuminate\View\View $view
       * @param $competitionSlug
       * @param $competitionId
       * @param int $page
       * @param null $stageId
       *
       * @throws \Exception
       * @return \Illuminate\View\View
       */
      public function compose(View $view, $competitionSlug, $competitionId, $page = 1, $stageId = null)
      {
          $viewData = $this->cache->remember(
              "CompetitionComposer_{$competitionSlug}_{$competitionId}_{$page}_{$stageId}",
              0.3,
              function () use ($view, $competitionSlug, $competitionId, $page, $stageId) {
                  $view->with('competitionId', $competitionId);
                  $view->with('competitionSlug', $competitionSlug);
  
                  // Load competition stages.
                  $this->loadStages($view, $competitionId, $stageId);
  
                  // Load review posts.
                  $this->loadPosts($view, $view->stage->tree, $page);
  
                  // Load standings.
                  $this->loadTables($view, $view->stages);
  
                  // Load fixtures.
                  $this->loadFixtures($view, $view->stage->tree);
  
                  // Load guide.
                  $this->loadGuide($view, $view->season->id);
  
                  // Load stage stats.
                  $this->loadStats($view);
  
                  $this->setupCanonical($view, $competitionId, $competitionSlug, $page);
  
                  $view->with('tabs', $this->getExtraContentTabs($view));
  
                  return $view->getData();
              }
          );
  
          $view->with($viewData);
  
          return $view;
      }
  
      /**
       * Setup next and prev rel link.
       */
      protected function setupRelLinksHtml(View $view, $stageTree, $offset, int $page)
      {
          $hasMorePosts = (bool) $this->matchPostQuery->findByStageTree($stageTree, $offset + $this->postPerPage, 1);
          
          $view->with('relLinksHtml', Helpers::relLinks($hasMorePosts, $view->canonical, $page));
      }
  
      /**
       * Set up page canonical link.
       */
      protected function setupCanonical(View $view, int $competitionId, string $competitionSlug, int $page)
      {
          $routeParam = [
              'id' => $competitionId,
              'slug' => $competitionSlug,
          ];
  
          if ($page !== 1) {
              $routeParam['page'] = $page;
          }
  
          if ($view->season->id !== $view->seasons[0]->id) {
              $routeParam['stageId'] = $view->stage->parent;
          }
  
          $view->with('canonical', route('competition', $routeParam));
      }
  
      /**
       * Loads posts.
       *
       * @param \Illuminate\View\View $view
       * @param string $stageTree
       * @param int $page
       *
       * @throws \Exception
       */
      protected function loadPosts(View $view, $stageTree, $page)
      {
          $offset = $this->postPerPage * ($page - 1);
  
          $view->with('page', $page);
  
          $view->with('posts', $this->matchPostQuery->findByStageTree($stageTree, $offset, $this->postPerPage));
  
          // If we are not on first page and no posts have been found then this is not a valid view.
          if ($page > 1 && !$view->posts) {
              throw new Exception('NoPosts');
          }
  
          $this->setupRelLinksHtml($view, $stageTree, $offset, $page);
      }
  
      /**
       * Loads stages.
       *
       * @param \Illuminate\View\View $view
       * @param int $competitionId
       * @param int $stageId
       *
       * @throws \Exception
       */
      protected function loadStages(View $view, $competitionId, $stageId)
      {
          // Find competition's seasons.
          $seasons = $this->stageRepo->findSeasons($competitionId);
  
          if (!$seasons) {
              throw new Exception('NoSeasons');
          }
  
          // Set current season if stage is known.
          if ($stageId) {
              $season = $this->stageRepo->findSeasonOf($stageId);
          }
  
          // If season is not yet set then check if competition has a "default
          // season" property configured and use that to calculate season to show.
          // Currently we only support 'year' option which will choose default
          // season to correspond with current year.
          if (!isset($season)) {
              $competition = $this->stageRepo->findById($competitionId);
  
              if (isset($competition->meta->defaultSeason) && $competition->meta->defaultSeason === 'year') {
                  $currentYear = date('Y');
  
                  foreach ($seasons as $s) {
                      if ($s->meta->year == $currentYear) {
                          $season = $s;
                          break;
                      }
                  }
              }
          }
  
          // If season is not yet set then choose the latest one from the
          // competition's seasons.
          if (!isset($season)) {
              $season = $seasons[0];
          }
  
          // Get all of the current season's stages.
          $stages = $this->stageRepo->findStagesByTree($season->tree);
  
          if (!$stages) {
              throw new Exception('NoStages');
          }
  
          if (count($stages) === 1) {
              // If there is only one stage in this season then set it to be the
              // current stage.
              $stage = $stages[0];
          } elseif ($stageId) {
              $stage = $this->searchStagesById($stageId, $stages);
          }
  
          // If stage is not yet set, then set it to current season by default.
          if (!isset($stage)) {
              $stage = $season;
          }
  
          $view->with('seasons', $seasons);
          $view->with('stages', $stages);
          $view->with('season', $season);
          $view->with('stage', $stage);
      }
  
      /**
       * Loads tables.
       *
       * @param \Illuminate\View\View $view
       * @param array $stages
       */
      protected function loadTables(View $view, array $stages)
      {
          $enetStageIds = [];
  
          if (count($stages) > 0) {
              foreach ($stages as $stage) {
                  /**
                   * TODO: This implementation for looking up tables depends on
                   * enetStageId. We should instead look up by our own stage id.
                   */
                  if (isset($stage->meta->enetStageId)) {
                      $enetStageIds[] = (int) $stage->meta->enetStageId;
                  }
              }
          }
  
          $cursor = $this->tableRepo->findByEnetStageIds($enetStageIds);
  
          $tables = [];
  
          // There may be more than one table returned (such as group tables).
          foreach ($cursor as $table) {
              $tables[] = $table;
          }
  
          $view->with('tables', $tables);
      }
  
      /**
       * Loads fixtures.
       *
       * @param \Illuminate\View\View $view
       * @param string $stageTree
       */
      protected function loadFixtures(View $view, $stageTree)
      {
          $matchDays = MatchDays::getDays(
              $this->matchRepo->distinctTimesByStageTree($stageTree)
          );
  
          // Figure out the date of Monday of the week in which current match day falls.
          if (date('w', strtotime($matchDays['currentDay'])) === '1') {
              $minDate = strtotime('this Monday', strtotime($matchDays['currentDay']));
          } else {
              $minDate = strtotime('last Monday', strtotime($matchDays['currentDay']));
          }
  
          $view->with('matches', $this->matchRepo->find([
              'stageTree' => $stageTree,
              'minDate' => $minDate,
              'maxDate' => strtotime('next Monday', strtotime($matchDays['currentDay'])) - 1,
          ]));
  
          $view->with('matchDays', $matchDays);
      }
  
      /**
       * Loads stage guide.
       *
       * @param \Illuminate\View\View $view
       * @param int $stageId
       */
      protected function loadGuide(View $view, $stageId)
      {
          $view->with('guide', $this->guideRepo->findOneByStageId($stageId));
      }
  
      /**
       * Searches given stages by id and returns the first found one.
       *
       * @param int $stageId
       * @param array $stages
       *
       * @return array|null
       */
      protected function searchStagesById($stageId, $stages)
      {
          foreach ($stages as $stage) {
              if ($stage->id === $stageId) {
                  return $stage;
              }
          }
  
          return null;
      }
  
      /**
       * Decides which extra content tab should be active.
       *
       * @param \Illuminate\View\View $view
       *
       * @return array[string]
       */
      protected function getExtraContentTabs(View $view): array
      {
          $tabs = [];
  
          if ($view->guide) {
              $tabs[] = 'guide';
          }
  
          if (count($view->matches) > 0) {
              $tabs[] = 'fixtures';
          }
          
          if ($view->tables) {
              $tabs[] = 'tables';
          }
  
          if ($view->stats) {
              $tabs[] = 'stats';
          }
          
          return $tabs;
      }
  
      /**
       * Load stats into view.
       *
       * @param \Illuminate\View\View $view
       */
      protected function loadStats(View $view): void
      {
          $currentStageTree = explode(',', $view->stage->tree);
          
          if (count($currentStageTree) > 2 && $this->isProperOrQualifiers((int) $currentStageTree[2], $view->stages)) {
              $stats = $this->statsRepo->findByStageId((int) $currentStageTree[2]);
          } else if (count($currentStageTree) === 2) {
              [$qualifiers, $proper] = $this->getQualifiersAndProper($view);
  
              if ($proper) {
                  $stats = $this->statsRepo->findByStageId($proper->id);
              }
  
              if ($qualifiers && !isset($stats)) {
                  $stats = $this->statsRepo->findByStageId($qualifiers->id);
              }
          }
  
          if (!isset($stats)) {
              $stats = $this->statsRepo->findByStageId($view->season->id);
          }
          
          $view->with('stats', $stats);
      }
  
      protected function getQualifiersAndProper($view)
      {
          $qualifiers = null;
          $proper = null;
          
          foreach ($view->stages as $stage) {
              if (!$proper && $stage->name === 'Tournament Proper') {
                  $proper = $stage;
              }
  
              if (!$qualifiers && preg_match('/^qualif/i', $stage->name)) {
                  $qualifiers = $stage;
              }
  
              if ($proper && $qualifiers) {
                  break;
              }
          }
  
          return [$qualifiers, $proper];
      }
  
      /**
       * Given a third level stage id that is within current season, will let you know if this
       * stage is tournament proper or a qualifiers stage.
       *
       * @param int $stageId
       *
       * @return bool
       */
      protected function isProperOrQualifiers(int $stageId, $stages): bool
      {
          $stage = $this->searchStagesById($stageId, $stages);
  
          if ($stage->name === 'Tournament Proper' || preg_match('/^qualif/i', $stage->name)) {
              return true;
          }
  
          return false;
      }
  }