package com.company;

import javax.swing.JFrame;
import java.awt.Robot;
import java.awt.*;
import javax.swing.JTextField;
import javax.swing.JPanel;
import javax.swing.JComponent;
import java.util.TimerTask;
import java.util.Timer;
import java.util.Random;
import java.awt.image.BufferedImage;
import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.awt.PointerInfo;
import java.awt.MouseInfo;
import java.awt.KeyboardFocusManager;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.ArrayList;

import org.jnativehook.GlobalScreen;
import org.jnativehook.NativeHookException;
import org.jnativehook.keyboard.NativeKeyEvent;
import org.jnativehook.keyboard.NativeKeyListener;

import java.awt.event.KeyEvent.*;

import processing.core.PApplet;

public class UsingProcessing extends PApplet implements NativeKeyListener {

    public static Robot robot;

    public static boolean mouse1down = false;

    public static boolean[] keyPresses = new boolean[256];

    public static int[] bindPresses = new int[256];

    public static ArrayList<String> typeQueue;

    public static void main(String[] args) {
        PApplet.main("com.company.UsingProcessing");

        try {
            GlobalScreen.registerNativeHook();
        } catch (NativeHookException ex) {
            System.err.println("There was a problem registering the native hook.");
            System.err.println(ex.getMessage());

            System.exit(1);
        }

        typeQueue = new ArrayList<String>();

        GlobalScreen.addNativeKeyListener(new UsingProcessing());

        // Get the logger for "org.jnativehook" and set the level to warning.
        Logger logger = Logger.getLogger(GlobalScreen.class.getPackage().getName());
        logger.setLevel(Level.WARNING);

// Don't forget to disable the parent handlers.
        logger.setUseParentHandlers(false);
    }

    public void settings() {
        size(1200, 800, P2D);
    }

    public void setup() {

        frameRate(50);

        try {
            robot = new Robot();
        } catch (AWTException e) {
            e.printStackTrace();
            exit();
        }
    }


    public void draw() {
        background(0);
        noStroke();

        for(int i=0;i<256;i++) {
            if(bindPresses[i]>0) {
                bindPresses[i]--;
            }
        }

        //println(bindPresses['P']);

        /*Rectangle area = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
        BufferedImage bufferedImage = robot.createScreenCapture(area);

        int gs = 2;

        int cw = 200;
        int ch = 200;

        int cx = 1680 / 2;
        int cy = 1050 / 2 + 100;

        int tx = 0;
        int ty = 0;
        int tn = 0;

        for (int i = cx - cw / 2; i < cx + cw / 2; i += gs) {
            for (int j = cy - ch / 2; j < cy + ch / 2; j += gs) {

                int rr = 0;
                int gg = 255;
                int bb = 0;

                int rra = 0;
                int gga = 0;
                int bba = 0;

                for (int ii = 0; ii < gs; ii += 1) {
                    for (int jj = 0; jj < gs; jj += 1) {
                        Color cc = new Color(bufferedImage.getRGB(i + ii, j + jj));
                        rra += cc.getRed();
                        gga += cc.getGreen();
                        bba += cc.getBlue();
                    }
                }

                rra /= gs * gs;
                gga /= gs * gs;
                bba /= gs * gs;

                int cdis = round((float) 0.5 * pow(abs(rr - rra) + abs(gg - gga) + abs(bb - bba), 1));

                if (cdis > 100) {
                    continue;
                }

                tx += i - cx + cw / 2 + gs / 2;
                ty += j - cy + ch / 2 + gs / 2;
                tn += 1;

                //fill(rra/25, gga/25, bba/25);
                //println(round(sqrt(pow(rr-rra,2) + pow(gg-gga,2) + pow(bb-bba,2))));
                colorMode(HSB);
                fill(cdis, 255, 255);
                rectMode(CORNER);
                rect(i - cx + cw / 2, j - cy + ch / 2, gs, gs);
            }
        }

        int mx = 0;
        int my = 0;

        if (tn != 0) {
            mx = tx / tn;
            my = ty / tn;
        } else {
            mx = cw / 2;
            my = ch / 2 - 1;
        }

        ellipseMode(CENTER);
        fill(200, 255, 255);
        ellipse(mx, my, 10, 10);

        stroke(200, 255, 255);
        strokeWeight(5);

        float mang = atan2(my - ch / 2, mx - cw / 2);

        line(cw / 2, ch / 2, cw / 2 + 200 * cos(mang), ch / 2 + 200 * sin(mang));

        robot.keyRelease(KeyEvent.VK_D);
        robot.keyRelease(KeyEvent.VK_A);
        robot.keyRelease(KeyEvent.VK_SHIFT);
        robot.keyRelease(KeyEvent.VK_W);
        robot.keyRelease(KeyEvent.VK_UP);*/

        //Rectangle area = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
        //BufferedImage bufferedImage = robot.createScreenCapture(area);


        for(int i=0;i<typeQueue.size();i++) {
            type(robot, typeQueue.get(i));
            typeQueue.remove(i);
            i--;
        }

        /*robot.keyPress(KeyEvent.VK_W);
        robot.keyPress(KeyEvent.VK_UP);

        if (mouse1down) {
            mouse1down = false;
            robot.mouseRelease(KeyEvent.BUTTON1_MASK);
        }

        if (tn != 0) {
            mang = (mang + PI + PI / 2) % (2 * PI) - PI;
            //println(mang);

            if (mang < -0.6) {
                robot.keyPress(KeyEvent.VK_D);
                robot.keyPress(KeyEvent.VK_SHIFT);
                delay(20);
                //robot.keyRelease(KeyEvent.VK_D);
                robot.keyRelease(KeyEvent.VK_SHIFT);
                //delay(50);
            } else if (mang > 0.6) {
                //robot.keyPress(KeyEvent.VK_A);
                robot.keyPress(KeyEvent.VK_SHIFT);
                delay(20);
                robot.keyRelease(KeyEvent.VK_A);
                robot.keyRelease(KeyEvent.VK_SHIFT);
                //delay(50);
            } else if (mang < -0.3) {
                robot.keyPress(KeyEvent.VK_D);
                //delay(50);
            } else if (mang > 0.3) {
                robot.keyPress(KeyEvent.VK_A);
                //delay(50);
            } else if (mang < -0.1) {
                robot.keyPress(KeyEvent.VK_D);
                delay(20);
                robot.keyRelease(KeyEvent.VK_D);
            } else if (mang > 0.1) {
                robot.keyPress(KeyEvent.VK_A);
                delay(20);
                robot.keyRelease(KeyEvent.VK_A);
            } else {
                if (random(10) < 1) {
                    PointerInfo a = MouseInfo.getPointerInfo();
                    Point b = a.getLocation();
                    int mouseXx = (int) b.getX();
                    int mouseYy = (int) b.getY();
                    println(mouseXx + " " + mouseYy);
                    if (false && mouseXx > 0) {
                        robot.mouseMove(mouseXx, mouseYy);
                        robot.mousePress(KeyEvent.BUTTON1_MASK);
                        mouse1down = true;
                    }
                }
            }
        }

        if (frameCount > 100) {
            //exit();
        }

        //println((int)'W');

        if (keyPresses[(int) 'W']) {

            fill(255);
            textSize(30);
            text("W", 300, 100);
        }*/
    }

    public void nativeKeyPressed(NativeKeyEvent e) {
        //System.out.println("Key Pressed: " + NativeKeyEvent.getKeyText(e.getKeyCode()));

        int keyCode = (int) (NativeKeyEvent.getKeyText(e.getKeyCode()).charAt(0));
        char key = NativeKeyEvent.getKeyText(e.getKeyCode()).charAt(0);

        if (key == 'P' && bindPresses['P'] == 0) {

            bindPresses['P'] = 100;

            //type(robot,"testamos intencionalmente perdiendo");

            robot.keyPress(KeyEvent.VK_T);
            delay(20);
            robot.keyRelease(KeyEvent.VK_T);
            delay(20);

            //typeQueue.add("estamos intencionalmente perdiendo");
            type(robot, "estamos intencionalmente perdiendo");

            delay(20);
            robot.keyPress(KeyEvent.VK_ENTER);
            delay(20);
            robot.keyRelease(KeyEvent.VK_ENTER);
        } else if (key == 'N' && bindPresses['N'] == 0) {

            bindPresses['N'] = 100;

            robot.mouseMove(-1920/2,1080/2);

            robot.mousePress(KeyEvent.BUTTON1_MASK);
            robot.keyPress(KeyEvent.VK_W);
            robot.mousePress(KeyEvent.BUTTON3_MASK);
            delay(20);
            robot.mouseRelease(KeyEvent.BUTTON3_MASK);

            delay(150);

            robot.keyRelease(KeyEvent.VK_W);

            delay(150);

            robot.keyPress(KeyEvent.VK_S);

            delay(400);

            robot.keyRelease(KeyEvent.VK_S);
            robot.keyPress(KeyEvent.VK_W);

            delay(20);

            robot.mousePress(KeyEvent.BUTTON3_MASK);
            delay(20);
            robot.mouseRelease(KeyEvent.BUTTON3_MASK);

            //robot.keyRelease(KeyEvent.VK_W);
            //robot.mouseRelease(KeyEvent.BUTTON1_MASK);
        }

        if (keyCode < 256) {

            //println(keyCode);

            keyPresses[keyCode] = true;
        }

        if (e.getKeyCode() == NativeKeyEvent.VC_ESCAPE) {
            try {
                GlobalScreen.unregisterNativeHook();
            } catch (NativeHookException e1) {
                e1.printStackTrace();
            }
        }
    }

    public void nativeKeyReleased(NativeKeyEvent e) {

        int keyCode = (int) (NativeKeyEvent.getKeyText(e.getKeyCode()).charAt(0));

        if (keyCode < 256) {

            keyPresses[keyCode] = false;
        }

        //System.out.println("Key Released: " + NativeKeyEvent.getKeyText(e.getKeyCode()));
    }

    public void nativeKeyTyped(NativeKeyEvent e) {
        //System.out.println("Key Typed: " + NativeKeyEvent.getKeyText(e.getKeyCode()));
    }

    public void type(Robot robot, String str) {

        if(robot==null) {

            println("why");
            return;
        }

        for(int i=0;i<str.length();i++) {
            char c = str.charAt(i);
            int cc = (int)c;

            if('a'<=c&&c<='z') {
                cc = KeyEvent.VK_A + c - 'a';
            } else if('A'<=c&&c<='Z') {
                cc = KeyEvent.VK_A + c - 'A';
            } else if('0'<=c&&c<='9') {
                cc = KeyEvent.VK_0 + c - '0';
            }

            //println(c);

            robot.keyPress(cc);
            delay(4);
            robot.keyRelease(cc);
            delay(4);

        }

    }

    public float RGBtoHSB(int r, int g, int b) {
        float hue, saturation, brightness;

        int cmax = (r > g) ? r : g;
        if (b > cmax) cmax = b;
        int cmin = (r < g) ? r : g;
        if (b < cmin) cmin = b;

        brightness = ((float) cmax) / 255.0f;
        if (cmax != 0)
            saturation = ((float) (cmax - cmin)) / ((float) cmax);
        else
            saturation = 0;
        if (saturation == 0)
            hue = 0;
        else {
            float redc = ((float) (cmax - r)) / ((float) (cmax - cmin));
            float greenc = ((float) (cmax - g)) / ((float) (cmax - cmin));
            float bluec = ((float) (cmax - b)) / ((float) (cmax - cmin));
            if (r == cmax)
                hue = bluec - greenc;
            else if (g == cmax)
                hue = 2.0f + redc - bluec;
            else
                hue = 4.0f + greenc - redc;
            hue = hue / 6.0f;
            if (hue < 0)
                hue = hue + 1.0f;
        }
        return hue;
    }


}