<?php

namespace CorpusParole\Http\Controllers\Sparql;

use Log;

use Illuminate\Http\Request;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Pagination\Paginator;

use GuzzleHttp\Client;
use EasyRdf\Sparql\Result as SparqlResult;
use EasyRdf\Graph;
use EasyRdf\RdfNamespace;

use CorpusParole\Http\Controllers\Controller;
use CorpusParole\Libraries\Utils;

use CorpusParole\Libraries\Sparql\SparqlClient;
use CorpusParole\Libraries\Sparql\SparqlQueryAnalyser;
use RdfHelper;

class SparqlClientController extends Controller
{

    const HEADERS_FORWARDED = [ "host", "user-agent", "accept", "accept-language", "accept-encoding", "connection" ];

    const SELECT_RESULT_FORMAT = [
        "SPARQL/CSV" => "text/csv",
        "SPARQL/JSON" => "application/sparql-results+json",
        "SPARQL/XML" => "application/sparql-results+xml",
        "SPARQL/TSV" => "text/tab-separated-values",
        "BINARY" => "application/x-binary-rdf-results-table"
    ];

    const GRAPH_RESULT_FORMAT = [
        "N-Triples" => "application/n-triples",
        "RDF/XML" => "application/rdf+xml",
        "Turtle" => "text/turtle",
        "N3" => "text/n3",
        "RDF/JSON" => "application/rdf+json",
        "TriG" => "application/trig",
        "N-Quads" => "application/n-quads",
        "BinaryRDF" => "application/x-binary-rdf",
        "TriX" => "application/trix",
        "JSON-LD" => "application/ld+json"
    ];


    private $sparqlClient;
    private $httpClient;

    public function __construct(SparqlClient $sparqlClient, Client $httpClient) {
        $this->sparqlClient = $sparqlClient;
        $this->httpClient = $httpClient;
    }

    public function getSparqlClient($timeout = null) {
        if(is_null($timeout)) {
            $timeout = config('corpusparole.sparql_client_timeout');
        }
        $queryUrl = config('corpusparole.rdf4j_query_url');
        if($timeout > 0) {
            $queryUrl = $queryUrl .
                ((strlen(parse_url($queryUrl, PHP_URL_QUERY)) > 0)?"&":"?").
                "timeout=$timeout";
        }
        return new \EasyRdf\Sparql\Client($queryUrl, config('corpusparole.rdf4j_update_url'));
    }

    // display form
    public function index() {
        return view('sparql/sparqlClientForm');
    }

    private function readDocs($docs, $fields) {
        $results = [];
        foreach($docs as $row) {
            $results[] = array_reduce($fields, function($res, $field) use ($row) {
                if(isset($row->$field)) {
                    $res[$field] = RdfHelper::serialiseValue($row->$field);
                } else {
                    $res[$field] = "<span class=\"corpus-rdf-blank-value\">&nbsp;</span>";
                }
                return $res;
            }, []);
        }
        return $results;
    }

    private function abort($code, $message, $exception) {
        throw new \Symfony\Component\HttpKernel\Exception\HttpException($code, $message, $exception, []);
    }

    private function processQueryException($exception) {
        $message = $exception->getMessage();
        if($exception instanceof \EasyRdf\Http\Exception) {
            if(preg_match("/SPARQL\squery/", $message)) {
                $this->abort(400, "La requête SPARQL n'est pas reconnue", $exception);
            } else {
                $this->abort(500, "Problème HTTP lors de la requête SPARQL", $exception);
            }
        } elseif($exception instanceof \EasyRdf\Exception) {
            if(preg_match("/timed\sout/i", $message)) {
                $this->abort(408, "Time-out causé par la requête SPARQL", $exception);
            } else {
                $this->abort(500, "Problème dans la requête SPARQL", $exception);
            }
        } else {
            $this->abort(500, "Erreur serveur lors de la requête", $exception);
        }
    }

    private function querySelect(Request $request, $query, $analyser) {

        $limit = intval($request->input('limit', config('corpusparole.sparql_client_default_limit')));

        if($limit === 0 || !is_null($analyser->getLimit()) || !is_null($analyser->getOffset()) ) {
            try {
                $docs = $this->getSparqlClient()->query($query);
            } catch(\Exception $exception) {
                $this->processQueryException($exception);
            }

            $fields = $docs->getFields();
            $results = $this->readDocs($docs, $fields);
            $count = count($results);

        } else {

            $page = Paginator::resolveCurrentPage(config('corpusparole.pagination_page_param'));
            assert(is_null($page) || is_numeric($page));

            $offset = max(0,($page - 1) * $limit);

            try {
                $countResult = $this->getSparqlClient()->query($analyser->getCountQuery());
                $docs = $this->getSparqlClient()->query($query . " LIMIT $limit OFFSET $offset");
            } catch(\Exception $exception) {
                $this->processQueryException($exception);
            }


            $countField = $countResult->getFields()[0];
            $countResult->rewind();
            $count = $countResult->current()->$countField->getValue();

            $fields = $docs->getFields();

            $results = new LengthAwarePaginator($this->readDocs($docs, $fields), $count, $limit, $page, [
                'path' => Paginator::resolveCurrentPath(),
                'pageName' => config('corpusparole.pagination_page_param'),
            ]);
        }

        $namespaces = array_reduce(array_keys(RdfHelper::getPrefixes()), function($res, $p) {
            $res[$p] = RdfNamespace::namespaces()[$p];
            return $res;
        }, []);

        $data = [
            'query' => $query,
            'count' => $count,
            'fields' => $fields,
            'fieldPrefix' => "?",
            'results' => $results,
            'namespaces' => $namespaces,
            'downloadFormats' => self::SELECT_RESULT_FORMAT
        ];
        $view = 'sparql/sparqlClientResultList';
        return [$view, $data];
    }

    private function queryGraph(Request $request, $query, $analyser) {
        try {
            $docs = $this->getSparqlClient()->query($query);
        } catch(\Exception $exception) {
            $this->processQueryException($exception);
        }


        $fields = ["subject", "predicate", "object"];
        $results = [];
        foreach ($docs->resources() as $resource ) {
            foreach ($resource->propertyUris() as $property) {
                $propertyResource = $docs->resource($property);
                foreach ($resource->all($propertyResource) as $value) {
                    $results[] = [
                        'subject' => RdfHelper::serialiseValue($resource),
                        'predicate'=> RdfHelper::serialiseValue($propertyResource),
                        'object'=> RdfHelper::serialiseValue($value)
                    ];
                }
            }
        }
        $namespaces = array_reduce(array_keys(RdfHelper::getPrefixes()), function($res, $p) {
            $res[$p] = RdfNamespace::namespaces()[$p];
            return $res;
        }, []);


        $data = [
            'query' => $query,
            'count' => count($results),
            'fields' => $fields,
            'fieldPrefix' => "",
            'results' => $results,
            'namespaces' => $namespaces,
            'downloadFormats' => self::GRAPH_RESULT_FORMAT
        ];
        $view = 'sparql/sparqlClientResultList';

        return [$view, $data];
    }

    private function queryAsk(Request $request, $query, $analyser) {
        try {
            $result = $this->getSparqlClient()->query($query);
        } catch(\Exception $exception) {
            $this->processQueryException($exception);
        }

        $data = [
            'results' => $result,
            'namespaces' => $analyser->getPrefixes()
        ];

        $view = 'sparql/sparqlClientResultBoolean';
        return [$view, $data];
    }

    private function showHtml(Request $request) {

        $query = $request->input('query');

        $analyser = new SparqlQueryAnalyser($query);

        $queryType = $analyser->getQueryType();

        $namespaces = $analyser->getPrefixes();

        foreach($namespaces as $prefix => $nUri) {
            RdfNamespace::set($prefix,$nUri);
        }

        if($queryType === SparqlQueryAnalyser::SELECT_QUERY) {
            list($view, $data) = $this->querySelect($request, $query, $analyser);
        } elseif($queryType === SparqlQueryAnalyser::GRAPH_QUERY) {
            list($view, $data) = $this->queryGraph($request, $query, $analyser);
        } elseif($queryType === SparqlQueryAnalyser::ASK_QUERY) {
            list($view, $data) = $this->queryAsk($request, $query, $analyser);
        } else {
            abort(400, "La requête n'est pas reconnue");
        }

        return view($view, $data);

    }


    private function proxyQuery(Request $request, $format=null) {
        $query = $request->input('query');
        $headers = [];
        foreach (self::HEADERS_FORWARDED as $h) {
            $headerValue = $request->header($h);
            if($headerValue) {
                $headers[$h] = $headerValue;
            }
        }

        if(!empty($format)){
            $headers['Accept'] = $format;
        }

        $queryParams = $request->all();
        $queryParams['timeout'] = config('corpusparole.sparql_client_timeout');
        $queryUrl = config('corpusparole.rdf4j_query_url');

        try {
            $rdf4jResp = $this->httpClient->post($queryUrl, ['form_params' => $queryParams, 'headers' => $headers]);
        } catch(\GuzzleHttp\Exception\ServerException $exception) {
            if($exception->getCode() == 503) {
                $this->abort(408, "Time-out causé par la requête SPARQL", $exception);
            } else {
                $this->abort(500, "Problème lors de la requête SPARQL", $exception);
            }

        } catch(\GuzzleHttp\Exception\RequestException $exception) {
            $message = $exception->getMessage();
            if(preg_match("/MALFORMED\sQUERY/i", $message)) {
                $abortMessage = "Requête SPARQL mal-formée";
            } else {
                $abortMessage = "Problème lors de la requête SPARQL";
            }
            $this->abort($exception->getCode(), $abortMessage, $exception);
        } catch(\Exception $exception) {
            $this->abort(500, "Erreur serveur lors de la requête", $exception);
        }

        $resp = response((string)$rdf4jResp->getBody(), $rdf4jResp->getStatusCode());
        foreach ($rdf4jResp->getHeaders() as $name => $values) {
            if($name != 'Transfer-Encoding') {
                $resp->header($name, $values);
            }
        }

        return $resp;
    }

    // display result
    public function show(Request $request) {

        $format = $request->input('format');

        if($format === 'text/html') {
            return $this->showHtml($request);
        } else {
            return $this->proxyQuery($request, $format);
        }

    }

    // do the query
    public function query(Request $request) {
        return $this->proxyQuery($request);
    }

}