package adt.mainnode.controller;

import adt.mainnode.entity.Credentials;
import adt.mainnode.entity.ScanConfig;
import adt.mainnode.entity.Node;
import adt.mainnode.entity.TPMHash;
import adt.mainnode.entity.Vlan;
import adt.mainnode.repository.CredentialsRepository;
import adt.mainnode.repository.ScanConfigRepository;
import adt.mainnode.repository.TPMHashRepository;
import adt.mainnode.repository.NodeRepository;
import adt.mainnode.repository.VlanRepository;
import adt.mainnode.service.InitializeService;
import adt.mainnode.service.FileHashingService;
import adt.mainnode.service.TPMValidationService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
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.util.List;
import java.util.concurrent.Executors;
import javax.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.core.JsonProcessingException;
import java.io.FileWriter;

import org.apache.commons.codec.digest.DigestUtils;
import java.io.IOException;
import java.io.*;
import java.util.Arrays;
import java.util.ArrayList;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestController
@RequestMapping("configurations")//"initialize")
@Api(
        value = "/configurations",//"/initialize",
        produces = MediaType.APPLICATION_JSON_VALUE,
        tags = {"Configurations"}
)
@Slf4j
public class InitializeController {

    private final InitializeService initializeService;
    private final FileHashingService fileHashingService;
    private final NodeRepository nodeRepository;
    private final CredentialsRepository credentialsRepository;
    private final ScanConfigRepository scanConfigRepository;
    private final VlanRepository vlanRepository;
    private final TPMHashRepository tpmHashRepository;
    private final TPMValidationService tpmValidationService;
    @Value("${main.ip}")
    private String mainIP;

    @Autowired
    public InitializeController(InitializeService initializeService, TPMValidationService tpmValidationService, FileHashingService fileHashingService, TPMHashRepository tpmHashRepository,
                                NodeRepository nodeRepository, CredentialsRepository credentialsRepository, ScanConfigRepository scanConfigRepository, VlanRepository vlanRepository) {

        this.nodeRepository = nodeRepository;
        this.initializeService = initializeService;
        this.credentialsRepository = credentialsRepository;
        this.scanConfigRepository = scanConfigRepository;
        this.vlanRepository = vlanRepository;
        this.tpmHashRepository = tpmHashRepository;
        this.fileHashingService = fileHashingService;
        this.tpmValidationService = tpmValidationService;

        try {

            String target = new String("printenv");

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

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

            String line = "";
            while (line != null) {

                if (initializeService.getServerPort() != null && initializeService.getServerIP() != null && initializeService.getTpmPresence() != null) {
                    break;
                }

                if (line.contains("MAIN_IP=")) {

                    String[] sep = line.split("=");
                    if (sep.length == 2) {

                        initializeService.setServerIP(sep[1]);

                    }

                }


                if (line.contains("MAIN_PORT=")) {

                    String[] sep = line.split("=");
                    if (sep.length == 2) {

                        initializeService.setServerPort(sep[1]);

                    }

                }


                if (line.contains("TPM_PRESENCE=")) {

                    String[] sep = line.split("=");
                    if (sep.length == 2) {

                        initializeService.setTpmPresence(sep[1]);
                    }

                }

                line = reader.readLine();
            }

        } catch (Throwable t) {

            t.printStackTrace();
        }


        enableRequiredConfiguration();


        if (initializeService.getTpmPresence().equals("true") || initializeService.getTpmPresence().equals("tpm0")) {
            log.info("A TPM device has been detected.");

            if (tpmValidationService.verify_executableHash()) {

                tpmValidationService.verify_pcrHash();

            } else {
                log.info("No TPM device detected. Launching with regular functioning.");
            }


        }
    }


    @CrossOrigin
    @ApiOperation(value = "Save a new node and saves its configuration", response = Node.class)
    @ResponseStatus(HttpStatus.CREATED)
    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
    Node saveNode(HttpServletResponse response, HttpServletRequest httpServletRequest, @RequestParam(value = "token"/*, required = false*/) String token) {
        Credentials credential = credentialsRepository.findByToken(token);

        if(credential != null) {

            List<ScanConfig> scanConfigs = scanConfigRepository.findAllByNodeId(credential.getName());
            if (scanConfigs != null) {

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

                    Node node = nodeRepository.findByNodeId(credential.getName());
                    Node nodeR = node;
                    boolean flag = (node != null);
                    if (!flag) {

                        log.info("No information from this node was found. Creating new instance.");
                        node = new Node();
                        node.setNodeId(credential.getName());
                        node.setIp(httpServletRequest.getRemoteAddr());

                        nodeR = initializeService.saveNode(node, scanConfigs, flag);

                    } else {
                        log.info("There was previous information about this node.");
                        log.info("Node ID: {}", nodeR.getNodeId());
                        if(!nodeR.getIp().equals(httpServletRequest.getRemoteAddr())){

                            nodeR.setIp(httpServletRequest.getRemoteAddr());
                        }

                        List<Vlan> vlans = vlanRepository.findAllByDistributedNodeId(credential.getName());
                        nodeR.setVlan(vlans);
                        nodeRepository.save(nodeR);

                        log.info("Delay associated with its vlans: {}", vlans.get(0).getDelay());
                    }

                    return nodeR;

                }
            }
        }

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

        return null;
    }


    public void enableRequiredConfiguration() {

        try {

            String target = new String("ldconfig -v");

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

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

            String line = "";
            while (line != null) {

                line = reader.readLine();
            }

        } catch (Throwable t) {

            t.printStackTrace();
        }
    }


}