<?php

/*
 * This file is part of the Maestro Project.
 * Copyright (C) Compos Juliot
 */

namespace App\Command;

use App\Application\Exception\SubException\UnhautorizedMaestroException;
use App\Application\Exception\SubException\UnprocessableEntityMaestroException;
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 App\Infrastructure\Adapter\HttpClientInterface;
use DateTime;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use App\Domain\Adapter\PageAutoGeneRepositoryInterface;
use App\Domain\Adapter\PageDuplicateRepositoryInterface;
use App\Domain\Adapter\PageRepositoryInterface;
use App\Domain\Entity\Page;
use App\Domain\Entity\PageDuplicate;

class AutoGenePageCommand extends Command
{
     /** @var PageAutoGeneRepositoryInterface */
     private $pageAutoGeneRepository;

     /** @var HttpClientInterface */
     public $httpClient;

     /** @var ParameterBagInterface */
     public $params;

     /** @var PageRepositoryInterface */
     public $pageRepository;

     /** @var PageDuplicateRepositoryInterface */
     public $pageDuplicateRepository;

     public function __construct(
          HttpClientInterface $httpClient,
          ParameterBagInterface $params,
          PageAutoGeneRepositoryInterface $pageAutoGeneRepository,
          PageRepositoryInterface $pageRepository,
          PageDuplicateRepositoryInterface $pageDuplicateRepository
     ) {
          parent::__construct();
          $this->pageAutoGeneRepository = $pageAutoGeneRepository;
          $this->httpClient = $httpClient;
          $this->params = $params;
          $this->pageRepository = $pageRepository;
          $this->pageDuplicateRepository = $pageDuplicateRepository;
     }

     protected function configure()
     {
          $this->setName('generation:auto')
               ->setDescription('Generate all pending pages')
               ->addArgument('page_options', InputArgument::OPTIONAL, 'Page options id')
               ->addArgument('page_duplicates', InputArgument::OPTIONAL, 'Search for PageDuplicate only ?')
               ->addArgument('token', InputArgument::OPTIONAL, 'Authentication token (INTERNAL ONLY)');
     }

     public function execute(InputInterface $input, OutputInterface $output)
     {
          $pageOptions = $input->getArgument('page_options');
          $pageDuplicates = $input->getArgument('page_duplicates');
          $token = $input->getArgument('token');

          if (null === $token) {
               $connect = $this->httpClient->data(
                    'POST',
                    $this->params->get('domain_admin_auth') . '/sign_in.json',
                    [
                         'json' => ["email" => $this->params->get('maestro_email'), "password" => $this->params->get('maestro_password')]
                    ]
               );

               if (isset($connect['data']) && isset($connect['data']['jwt'])) {
                    $token = $connect['data']['jwt'];
               } else {
                    throw new UnhautorizedMaestroException("Missing parameters from authentication response !");
               }
          }

          if (null === $pageOptions || empty($pageOptions)) {
               $pagesAuto = $this->pageAutoGeneRepository->list();
          } else {
               if (null === $pageDuplicates || empty($pageDuplicates)) {
                    $arrayPageDuplicates = [];
               } else {
                    $arrayPageDuplicates = explode(";", $pageDuplicates);
               }

               $arrayPageOptions = explode(";", $pageOptions);

               $pagesAuto = $this->pageAutoGeneRepository->findByPageOptions($arrayPageOptions, $arrayPageDuplicates);
          }

          $generated = 0;
          $pagesFromDb = [];

          if (!empty($arrayPageDuplicates)) {
               foreach ($pagesAuto as $pageAuto) {
                    $pagesFromDb[] = $pageAuto->getPageDuplicate();
               }
          } else {
               $pagesFromDb = $this->pageRepository->findByOptions($arrayPageOptions);
          }

          foreach ($pagesFromDb as $pageFromDb) {
               if ($pageFromDb instanceof Page) {
                    $option = $pageFromDb->getOption();
                    $pageId = $pageFromDb->getId();
                    $pageDupliId = null;
                    $versionExportId = null;
               } else if ($pageFromDb instanceof PageDuplicate) {
                    $option = $pageFromDb->getPage()->getOption();
                    $pageId = $pageFromDb->getPage()->getId();
                    $pageDupliId = $pageFromDb->getId();
                    $versionExportId = $pageFromDb->getVersion()->getId();
               } else {
                    throw new UnprocessableEntityMaestroException("Unhandled object " . get_class($pageFromDb));
               }

               $output->write($option->getName());

               $result = $this->httpClient->data(
                    'POST',
                    $this->params->get('domain_project') . '/generate.json',
                    [
                         'headers' => [
                              'x-auth-token' => $token,
                         ],
                         'json' => [
                              "generationType" => 0,
                              "pageDuplicateId" => $pageDupliId,
                              "page" => $pageId,
                              "versionExport" => $versionExportId
                         ]
                    ]
               );

               $optionId = $option->getId();

               if ($result["type"] == "success") {
                    foreach ($pagesAuto as $pageAuto) {
                         if ($pageAuto->getPageOption()->getId() === $optionId) {
                              $pageAuto->setDateGeneration(new DateTime());
                              $generated++;
                         }
                    }

                    $this->pageAutoGeneRepository->saveMultiple($pagesAuto);
               } else {
                    $output->write("Unable to generate $optionId");
               }
          }

          $output->write("SUCCESS= $generated / " . count($pagesAuto) . " pages generation launched =SUCCESS");

          return 1;
     }
}