<?php

namespace CorpusParole\Console\Commands;

use Illuminate\Console\Command;

use GuzzleHttp\Client;

use CorpusParole\Repositories\DocumentRepository;

use CorpusParole\Libraries\CocoonUtils;

use CorpusParole\Models\GeonamesHierarchy;

use Es;

class IndexDocuments extends Command

{

    /**

     * The name and signature of the console command.

     *

     * @var string

     */

    protected $signature = 'corpus-parole:indexDocuments

                          {--limit=0 : index only the first n documents, 0 (default) means index everything }

                          {--no-bulk : index documents one by one instead of using ElasticSearch bulk indexing }

                          {--step-size=100 : number of documents to retrieve from repository at a time before indexing}';

    /**

     * The console command description.

     *

     * @var string

     */

    protected $description = 'Index documents into ElasticSearch.';

    /**

     * Create a new command instance.

     *

     * @return void

     */

    public function __construct(DocumentRepository $documentRepository, Client $httpClient)

    {

        $this->documentRepository = $documentRepository;

        $this->httpClient = $httpClient;

        parent::__construct();

    }

    /**

     * Reset Elasticsearch index

     *

     * @return int (1 if sucess, 0 if error)

     */

    private function resetIndex()

    {

        $indexParams = [

            'index' => env('ELASTICSEARCH_INDEX')

        ];

        if(Es::indices()->exists($indexParams)){

            $response = Es::indices()->delete($indexParams);

            if($response['acknowledged']!=1){

                return 0;

            }

        }

        // Note: removed the "'store' => True" parameters on fields and use _source on record instead

        $indexParams['body'] = [

            'settings' => [

                'number_of_shards' => config('elasticsearch.shards'),

                'number_of_replicas' => config('elasticsearch.replicas'),

                'index.mapping.ignore_malformed' => True

            ],

            'mappings' => [

                'document' => [

                    'properties' => [

                        'title' => [

                            'type' => 'string',

                            'fields' => [

                                'raw' => [

                                    'type' => 'string',

                                    'index' => 'not_analyzed'

                                ]

                            ]

                        ],

                        'date' => [ 'type' => 'date' ],

                        'geonames_hyerarchy' => [ 'type' => 'string' ],

                        'location' => [ 'type' => 'geo_point' ]

                        // TODO: add location information

                    ]

                ]

            ]

        ];

        $response = Es::indices()->create($indexParams);

        if($response['acknowledged']!=1){

            return 0;

        }

        return 1;

    }

    private function getGeonamesHierarchyArray($geonamesid) {

        // TODO: Manage this cache !!!

        $hcache = GeonamesHierarchy::where('geonamesid', $geonamesid)->first();

        if(is_null($hcache)) {

            // TODO: add delay to respect geonames 2k request/hour

            // TODO: manage errors

            $apiBody = $this->httpClient->get(

                config('corpusparole.geonames_hierarchy_webservice_url'),

                [ 'query' =>

                    [ 'geonameId' => $geonamesid,

                      'username' => config('corpusparole.geonames_username') ],

                  'accept' => 'application/json' // TODO: check this

                ]

            )->getBody();

            $hjson = json_decode($apiBody);

            $hcache = new GeonamesHierarchy;

            $hcache->geonamesid = $geonamesid;

            $hcache->hierarchy = $hjson;

            $hcache->save();

        }

        $res = [];

        foreach($hcache->hierarchy['geonames'] as $hierarchyElem) {

            if(in_array($hierarchyElem['fcode'], ['CONT','PCLI', 'PCL','PCLD', 'PCLF', 'PCLH', 'PCLIX', 'PCLIS', 'ADM1'])) {

                array_push($res, $hierarchyElem['geonameId']);

            }

        }

        return $res;

    }

    /**

     * get geonames hierarchy data.

     * @return array list of geonames ids

     */

    private function getGeonamesHierarchy($doc) {

        $geoRes = $doc->getGeoInfo();

        if(is_null($geoRes)) {

            return [];

        }

        // aggregate hierachy list from geonames results

        $res = [];

        foreach($geoRes->getGeonamesLocs() as $gurl) {

            $geonamesId = CocoonUtils::getGeonamesidFromUrl($gurl);

            if(is_null($geonamesId)) {

                continue;

            }

            $hierarchyIds = $this->getGeonamesHierarchyArray($geonamesId);

            $res = array_unique(array_merge($res, $hierarchyIds));

        }

        return $res;

    }

    /**

     * Index one document into Elasticsearch

     *

     * @return int (1 if sucess, 0 if error)

     */

    private function indexOne($resultDoc)

    {

        $doc = $this->documentRepository->get($resultDoc->getId());

        $query_data = [

            'index' => config('elasticsearch.index'),

            'type' => 'document',

            'id' => (string)$doc->getId(),

            'body' => [

                'title' => (string)$doc->getTitle(),

                'date' => (string)$doc->getModified(),

                'geonames_hierarchy' => $this->getGeonamesHierarchy($doc)

            ]

        ];

        Es::index($query_data);

    }

    /**

     * Index multiple document into Elasticsearch

     *

     * @return int (1 if sucess, 0 if error)

     */

     private function indexBulk($docs)

     {

          $query_data = ['body' => []];

          foreach($docs as $doc){

              $query_data['body'][] = [

                  'index' => [

                      '_index' => config('elasticsearch.index'),

                      '_type' => 'document',

                      '_id' => (string)$doc->getId()

                  ]

              ];

              $query_data['body'][] = [

                  'title' => (string)$doc->getTitle(),

                  'date' => (string)$doc->getModified()

              ];

          }

          Es::bulk($query_data);

     }

    /**

     * Execute the console command.

     *

     * @return mixed

     */

    public function handle()

    {

        $this->info('Options:');

        $noBulk = $this->option('no-bulk');

        if ($noBulk)

        {

            $this->comment(' - Indexing without bulk insert');

        }

        else

        {

            $this->comment(' - Indexing using bulk insert');

        }

        $limit = $this->option('limit');

        if ($limit>0) {

            $this->comment(' - Indexing only the first '.$limit.' documents');

        }

        $stepSize = $this->option('step-size');

        $this->comment(' - Indexing with step size of '.$stepSize);

        $this->info('Resetting index...');

        $success = $this->resetIndex();

        if($success==1){

            $this->comment('Index reset!');

        }

        else{

            $this->error('Error resetting index ' . env('ELASTICSEARCH_INDEX'));

        }

        $this->info('Indexing documents...');

        if ($limit<=0) {

            $lastPage = $this->documentRepository->paginateAll($stepSize, 'page')->lastPage();

            $total = $this->documentRepository->getCount();

            $lastPageEntryCount = $stepSize+1;

        }

        else {

            $lastPage = min((int)($limit/$stepSize)+1, $this->documentRepository->paginateAll($stepSize, 'page')->lastPage());

            $total = $limit;

            $lastPageEntryCount = $limit % $stepSize;

        }

        if ($noBulk)

        {

            $progressBar = $this->output->createProgressBar($total);

        }

        else

        {

            $progressBar = $this->output->createProgressBar($lastPage);

        }

        $progressBar->setFormat(' %current%/%max% [%bar%] %percent:3s%% - %message%');

        for ($page=1;$page<=$lastPage;$page++)

        {

            $docs = $this->documentRepository->paginateAll($stepSize, 'page', $page);

            if ($noBulk)

            {

                foreach ($docs as $i=>$doc){

                    if ($page==$lastPage && $i>=$lastPageEntryCount){

                        break;

                    }

                    $this->indexOne($doc);

                    $progressBar->advance();

                    $progressBar->setMessage($doc->getId());

                }

            }

            else

            {

                $this->indexBulk($docs);

                $progressBar->advance();

                $progressBar->setMessage('Page '.$page);

            }

        }

        $progressBar->finish();

        $this->info('Indexing completed');

    }

}