package adt.mainnode.controller;

import adt.mainnode.dto.Asset;
import adt.mainnode.dto.HostDto;
import adt.mainnode.dto.PortDto;
import adt.mainnode.entity.*;
import adt.mainnode.repository.CredentialsRepository;
import adt.mainnode.repository.ScanInfoRepository;
import adt.mainnode.repository.PortRepository;
import adt.mainnode.repository.HostRepository;
import adt.mainnode.repository.SnapshotRepository;
import adt.mainnode.repository.VlanRepository;
import java.util.ArrayList;
import adt.mainnode.service.AssetService;
import io.swagger.annotations.Api;
import javax.servlet.http.HttpServletRequest;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import adt.mainnode.service.InitializeService;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import org.springframework.beans.factory.annotation.Value;


@RestController
@RequestMapping("virt_query")
@Api(
        value = "/virt_query",
        produces = MediaType.APPLICATION_JSON_VALUE,
        tags = {"Virt_Query"}
)
@Slf4j
public class VirtuosoQueryController {

    private final CredentialsRepository credentialsRepository;
    private final InitializeService initializeService;
    private final ArrayList<String> outputTypes_valid;
    @Value("${main.ip}")
    private String mainIP;

    @Autowired
    public VirtuosoQueryController(InitializeService initializeService, CredentialsRepository credentialsRepository) {

        this.initializeService = initializeService;
        this.credentialsRepository = credentialsRepository;

        outputTypes_valid = new ArrayList<String>();
        outputTypes_valid.add("json");
        outputTypes_valid.add("xml");
        outputTypes_valid.add("turtle");
        outputTypes_valid.add("n3");
        outputTypes_valid.add("rdf");
        outputTypes_valid.add("rdf+xml");
        outputTypes_valid.add("csv");
        outputTypes_valid.add("tsv");

    }

    @CrossOrigin
    @ApiOperation(value = "Make a SPARQL query to Virtuoso. Valid output formats include: [json, xml, turtle, n3, rdf, rdf+xml, csv, tsv].", response = String.class)
    @ResponseStatus(HttpStatus.CREATED)
    @PostMapping(produces = MediaType.APPLICATION_JSON_VALUE)
    String queryVirtuoso(HttpServletRequest httpServletRequest,
                         HttpServletResponse response,
                         @RequestBody String query,
                         @RequestParam String outputFormat,
                         @RequestParam String token) {

        Credentials credential = credentialsRepository.findByToken(token);

        if(credential != null && credential.getStatus().equals("OPERATIVE")) {

            outputFormat = outputFormat.toLowerCase();

            if(query.length() == 0 || query.equals("{}")){

                try {
                    response.sendError(400, "Query was unspecified. Cannot process this input.");
                }catch(IOException ioe){
                    //
                }

                return null;
            }

            if(!outputTypes_valid.contains(outputFormat)){

                try {
                    response.sendError(400, "An invalid output format was specified. Please, check that it matches one of the following: [json, xml, turtle, n3, rdf, rdf+xml, csv, tsv].");
                }catch(IOException ioe){
                    //
                }

                return null;
            }

            if(credential.getAvailableEndpoint().contains("(GET) virt_query/")) {

                try{

                    log.info("New query to Virtuoso received");

                    PrintWriter writer = new PrintWriter("./virtuoso/query_info.txt", "UTF-8");
                    writer.println(query);
                    writer.println(outputFormat);
                    writer.println(httpServletRequest.getRemoteAddr());
                    writer.close();

                    String target = new String("python3 virtuoso/query_script.py http://" + initializeService.getServerIP() + ":8890/sparql-auth");

                    Runtime rt = Runtime.getRuntime();
                    Process proc = rt.exec(target);
                    int exitCode = proc.waitFor();

                    StringBuffer output = new StringBuffer();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));

                    Object obj = new FileReader("./queryresp_virtuoso.xml");
                    log.info("Virtuoso output processed: \n{}", obj);

                    byte[] encoded = Files.readAllBytes(Paths.get("./queryresp_virtuoso.xml"));

                    return new String(encoded, "utf-8");

                } catch (Throwable t) {

                    t.printStackTrace();
                }

            }
        }

        try {
            response.sendError(400, "Unrecognized token. Access denied.");
        }catch(IOException ioe){
            //
        }

        return null;
    }

}