package adt.mainnode.service;

import adt.mainnode.entity.Credentials;
import adt.mainnode.entity.ScanConfig;
import adt.mainnode.entity.Node;
import adt.mainnode.entity.ScanInfo;
import adt.mainnode.entity.Vlan;
import adt.mainnode.repository.CredentialsRepository;
import adt.mainnode.repository.ScanConfigRepository;
import adt.mainnode.repository.NodeRepository;
import adt.mainnode.repository.VlanRepository;
import adt.mainnode.service.InitializeService;
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 java.io.IOException;
import java.io.*;
import java.util.Arrays;
import java.util.ArrayList;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.core.Response.Status;
import java.io.IOException;
//import org.json.*;//JSONObject;
import java.util.*;
import java.net.*;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
import org.apache.http.client.methods.*;
import org.apache.http.impl.client.*;
//import org.springframework.http.*;
import org.apache.http.entity.mime.*;
import org.apache.http.entity.*;
import org.apache.http.*;
import org.apache.http.util.*;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.JSONArray;
import java.io.*;
//import javax.json.stream.*;
import adt.mainnode.entity.changed.*;


@Slf4j
@Service
public class SendToURLService {

    private final InitializeService initializeService;


    @Autowired
    public SendToURLService(InitializeService initializeService) {

        this.initializeService = initializeService;
    }

    void processEvent(List<String> transfer_urls, SnapshotChange object) {

        for(int i=0; i<transfer_urls.size(); i++) {

            log.info("SENDING SNAPSHOT CHANGE TO {}", transfer_urls.get(i));

            try {
                URL url = new URL(transfer_urls.get(i));

                HttpURLConnection con = (HttpURLConnection) url.openConnection();
                con.setRequestMethod("POST");
                con.setRequestProperty("Content-Type", "application/json");
                con.setRequestProperty("Accept", "application/json");
                con.setDoOutput(true);

                final ByteArrayOutputStream out = new ByteArrayOutputStream();
                final ObjectMapper mapper = new ObjectMapper();

                mapper.writeValue(out, object);

                final byte[] data = out.toByteArray();
                //System.out.println(new String(data));
                log.info(new String(data));

                try (OutputStream os = con.getOutputStream()) {
                    //byte[] input = jsonInputString.getBytes("utf-8");
                    os.write(data, 0, data.length);
                }

                try (BufferedReader br = new BufferedReader(
                        new InputStreamReader(con.getInputStream(), "utf-8"))) {
                    StringBuilder response = new StringBuilder();
                    String responseLine = null;
                    while ((responseLine = br.readLine()) != null) {
                        response.append(responseLine.trim());
                    }
                    log.info(response.toString());
                } catch (Exception ex) {
                    log.info("#######{}", ex);
                }

            } catch (Exception ex) {
                // handled
                log.info("#######{}", ex);
            }

        }


    }


    public static String getParamsString(Map<String, String> params)
            throws UnsupportedEncodingException{
        StringBuilder result = new StringBuilder();

        for (Map.Entry<String, String> entry : params.entrySet()) {
            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
            result.append("&");
        }

        String resultString = result.toString();
        return resultString.length() > 0
                ? resultString.substring(0, resultString.length() - 1)
                : resultString;
    }


    public static String extractIP(String s) {
        java.util.regex.Matcher m = java.util.regex.Pattern.compile(
                "(?<!\\d|\\d\\.)" +
                        "(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
                        "(?:[01]?\\d\\d?|2[0-4]\\d|25[0-5])" +
                        "(?!\\d|\\.\\d)").matcher(s);
        return m.find() ? m.group() : null;
    }


    public static String reAssembleURL(String url){

        String url_canon_init = "http://";

        if(extractIP(url) != null){

            if(url.length() < 7 || !url.substring(0,7).equals(url_canon_init)){

                url = url_canon_init + url;
            }
        }else{

            if(url.length() < 11 || !url.substring(0,11).equals(url_canon_init+"www.")){

                url = url_canon_init +"www."+ url;
            }
        }

        return url;

    }

    public static boolean token_caducity(Date token_receipt){

        Date token_receipt_date = token_receipt;

        long diff = new Date().getTime() - token_receipt_date.getTime();

        if(TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS) >= 7){

            return true;
        }

        return false;

    }

}