package org.proxy;

import org.json.simple.parser.ParseException;

import java.awt.*;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.*;
import java.util.List;
import java.util.Locale;

import static javax.swing.JOptionPane.showMessageDialog;
import static org.dhaverdLogs.DhaverdLogs.*;
import static org.proxy.loadConfig.*;

public class Main {

    public static boolean isLinux = System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("linux");
    public static ServerSocket serverSocket;
    public static int repeatTime;

    public static TrayIcon trayIcon = null;

    static {
        try {
            serverSocket = new ServerSocket();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static Thread currentThread = null;
    public static String currentProxyPub = " proxy is off";

    public static void main(String[] args) throws IOException, ParseException, InterruptedException {
        setLogDir("logs");
        setLogName("startup");
        logCleaner(getDeleteTime());
        bindSocket();
        repeatTime = getRepeatTime();
        currentProxyPub = getCurrentProxy();
        setLog("Proxy Checker", "Current proxy: " + currentProxyPub, true, false);
        systemTray();
    }

    public static String getCurrentProxy() throws InterruptedException, IOException {
        String currentProxy = " proxy is off";
        Process proc = Runtime.getRuntime().exec("reg query \"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\"");
        proc.waitFor();
        BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
        String s;
        String proxyLine = "";
        while ((s = stdInput.readLine()) != null) {
            if (s.contains("AutoConfigURL")){
                proxyLine = s.replace("    ", ";");
            }
        }
        String[] abc = proxyLine.split(";");
        if (abc.length == 4 && abc[3] != null) currentProxy = abc[3];
        proc.destroy();
        return currentProxy;
    }

    public static void bindSocket() throws IOException, ParseException {
        String context = "BindSocket";
        InetAddress inetAddress = InetAddress.getByName("localhost");
        int port = getSocketPort();
        SocketAddress endPoint = new InetSocketAddress(inetAddress, port);
        try {
            serverSocket.bind(endPoint);
        } catch (BindException e) {
            showMessageDialog(null, "Приложение уже запущено");
            exeptionActions(context, e);
            System.exit(0);
        }
        setLog(context, "Socket binded", true, false);
        setLog(context, "Local Socket Address: "+serverSocket.getLocalSocketAddress(), true, false);
    }

    public static void systemTray() throws IOException, ParseException {
        String context = "SystemTray";
        if(! SystemTray.isSupported() ) {
            setLog(context,"System tray is unsupported!", true, false);
            return;
        }
        Font trayFont;
        if (isLinux){
            trayFont = new Font("Tempora LGC Uni", Font.PLAIN, 16);
        } else {
            trayFont = new Font("Arial", Font.PLAIN, 12);
        }
        List<String> proxyList = getProxyList();
        PopupMenu trayMenu = new PopupMenu();
        for (String prox : proxyList){
            MenuItem proxy = new MenuItem(prox);
            proxy.setFont(trayFont);
            proxy.addActionListener(proxyListener(prox));
            trayMenu.add(proxy);
        }
        MenuItem stopButton = new MenuItem("Stop");
        stopButton.setFont(trayFont);
        stopButton.addActionListener(stopListener());
        trayMenu.add(stopButton);
        MenuItem trayExit = new MenuItem("Exit");
        trayExit.setFont(trayFont);
        trayExit.addActionListener(trayExitListener());
        trayMenu.add(trayExit);
        Image icon;
        icon = Toolkit.getDefaultToolkit().getImage("res" + osSeparator + "icon off.png");
        trayIcon = new TrayIcon(icon, "Current proxy: " + currentProxyPub, trayMenu);
        trayIcon.setImageAutoSize(!isLinux);
        SystemTray tray = SystemTray.getSystemTray();
        try {
            tray.add(trayIcon);
        } catch (AWTException e) {
            exeptionActions(context, e);
        }
        setLog(context,"System tray launched", true, false);
    }

    public static ActionListener trayExitListener() {
        return e -> {
            try {
                setLog("Program","Closing server socket...", true, false);
                setLog( "Program","Exiting program", true, false);
                serverSocket.close();
            } catch (IOException ex) {
                exeptionActions("TrayExitListener", ex);
            }
            closeThread();
            System.exit(0);
        };
    }
    public static ActionListener stopListener() {
        return e -> {
            closeThread();
            try {
                setLog("Stop Listener", "Proxy setter now is off", true, false);
            } catch (IOException ex) {
                exeptionActions("Stop Listener", ex);
            }
            Image icon = Toolkit.getDefaultToolkit().getImage("res" + osSeparator + "icon off.png");
            trayIcon.setImage(icon);
            currentThread  = new Thread(() -> {
                while(true){
                    try {
                        currentProxyPub = getCurrentProxy();
                        trayIcon.setToolTip("Current proxy: " + currentProxyPub);
                        Thread.sleep(repeatTime);
                    } catch (InterruptedException | IOException ex) {
                        exeptionActions("Stop Listener", ex);
                    }
                }
            });
            currentThread.start();
        };
    }
    public static void closeThread(){
        if (currentThread != null){
            currentThread.stop();
        }
        currentThread = null;
    }

    public static ActionListener proxyListener(String proxyStr) {
        return e -> {
            closeThread();
            currentThread = new Thread(() -> {
                while(true){
                    try {
                        currentProxyPub = getCurrentProxy();
                        if (!currentProxyPub.equals(proxyStr)) setProxy(proxyStr);
                        Image icon = Toolkit.getDefaultToolkit().getImage("res" + osSeparator + "icon on blue.png");
                        trayIcon.setImage(icon);
                        currentProxyPub = getCurrentProxy();
                        trayIcon.setToolTip("Current proxy: " + currentProxyPub);
                        Thread.sleep(repeatTime);
                    } catch (InterruptedException | IOException ex) {
                        exeptionActions( "Set proxy: " + proxyStr, ex);
                    }
                }
            });
            currentThread.start();
        };
    }

    public static void setProxy(String proxyStr) throws IOException, InterruptedException {
        execute("reg delete \"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\" /v AutoConfigURL /f");
        execute("reg add \"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\" /v AutoConfigURL /t REG_SZ /d \"" + proxyStr + "\"");
        setLog("Set Proxy", "Proxy is set on: " + proxyStr, true, false);
    }

    public static void execute(String command) throws IOException, InterruptedException {
        Process proc = Runtime.getRuntime().exec(command);
        proc.waitFor();
        proc.destroy();
    }
}