package shooter.main;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontFormatException;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;

import javax.swing.JFrame;

import shooter.gfx.BulletSpriteManager;
import shooter.gfx.ImageLoader;
import shooter.gfx.ObjectSpriteManager;
import shooter.gfx.SpriteSheet;
import shooter.gfx.TileSpriteManager;
import shooter.input.KeyInputHandler;
import shooter.input.MouseInputHandler;

public class Game extends Canvas implements Runnable {

    private static final String Version = "0.1";

    public static final int WIDTH = 480;
    public static final int HEIGHT = 360;
    public static final int SCALE = 2;
    public static final String NAME = "Twin-Stick Shooter";

    private Cursor scope;
    private Font eightBitWonder, sizedFont;
    private JFrame frame;

    private int fps = 0;
    private int ticks = 0;
    private int stringLen = 0;

    private boolean running = false;
    private boolean tick = true;
    private Thread gameThread;

    private ImageLoader loader;
    private BufferedImage bulletSpritesheet, tileSpritesheet, objectSpritesheet;
    private ObjectSpriteManager om;
    private TileSpriteManager tm;
    private BulletSpriteManager bm;
    private KeyInputHandler ki;
    private MouseInputHandler mi;

    private Handler h;
    private Menu menu;
    private HUD hud;
    private State state = State.MENU;

    public Game() {
        setMinimumSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
        setMaximumSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
        setPreferredSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));

        frame = new JFrame(NAME);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());

        frame.add(this, BorderLayout.CENTER);
        frame.setResizable(false);

        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    private void init() {
        menu = new Menu(this);
        hud = new HUD(this);
        loader = new ImageLoader();
        objectSpritesheet = loader.load("/gfx/objectSpritesheet.png");
        SpriteSheet os = new SpriteSheet(objectSpritesheet);
        bulletSpritesheet = loader.load("/gfx/bulletSpritesheet.png");
        SpriteSheet bs = new SpriteSheet(bulletSpritesheet);
        tileSpritesheet = loader.load("/gfx/tileSpritesheet.png");
        SpriteSheet ts = new SpriteSheet(tileSpritesheet);
        om = new ObjectSpriteManager(os);
        bm = new BulletSpriteManager(bs);
        tm = new TileSpriteManager(ts);

        ki = new KeyInputHandler(this);
        mi = new MouseInputHandler(this, menu);
        this.addKeyListener(ki);
        this.addMouseListener(mi);
        this.addMouseMotionListener(mi);

        h = new Handler(this);
        h.createObjects();
        initFont();
    }

    private void initFont() {
        InputStream is = Game.class.getResourceAsStream("/font/Emulator.ttf");
        try {
            eightBitWonder = Font.createFont(Font.TRUETYPE_FONT, is);
            sizedFont = eightBitWonder.deriveFont(12f);
        } catch (FontFormatException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Thread getGameThread() {
        return gameThread;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public Handler getHandler() {
        return h;
    }

    public ObjectSpriteManager getObjectImageManager() {
        return om;
    }

    public TileSpriteManager getTileImageManager() {
        return tm;
    }

    public BulletSpriteManager getBulletImageManager() {
        return bm;
    }

    public ImageLoader getImageLoader() {
        return loader;
    }

    public MouseInputHandler getMouseInputHandler() {
        return mi;
    }

    public Font getSizedFont() {
        return sizedFont;
    }

    public void setTick(boolean tick) {
        this.tick = tick;
    }

    public boolean isTick() {
        return tick;
    }

    public synchronized void start() {
        if (running) {
            return;
        }
        running = true;
        gameThread = new Thread(this);
        gameThread.start();
    }

    public synchronized void stop() {
        if (!running) {
            return;
        }
        running = false;
        try {
            gameThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void tick() {
        ki.tick();
        mi.tick();
        if (state == State.GAME) {
            h.tick();
        }
    }

    private void changeCursor() {
        //Get the default toolkit
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        //Load an image for the cursor
        BufferedImage image = loader.load("/gfx/aim.png");
        //Create the hotspot for the cursor
        Point hotSpot = new Point(16,16);
        scope = toolkit.createCustomCursor(image, hotSpot, "Scope");
        this.setCursor(scope);
    }

    private void drawPause(Graphics2D g2d, Font font) {
        g2d.setColor(Color.RED);
        g2d.setFont(new Font(font.getName(), Font.BOLD, 35));
        stringLen = (int) g2d.getFontMetrics().getStringBounds("P A U S E", g2d).getWidth();
        g2d.drawString("P A U S E", getWidth() / 2 - stringLen / 2, getHeight() / 2);
    }

    private void drawFPS(Graphics2D g2d, Font font) {
        g2d.setFont(new Font(font.getName(), Font.BOLD, 16));
        stringLen = (int) g2d.getFontMetrics().getStringBounds("Ticks:" + "    ", g2d).getWidth();
        g2d.drawString("Ticks:" + ticks, this.getWidth() - stringLen + 20, this.getHeight() - 10);
        int tempStringLen = stringLen;
        stringLen = (int) g2d.getFontMetrics().getStringBounds("FPS:" + "    ", g2d).getWidth();
        g2d.drawString("FPS:" + fps, this.getWidth() - stringLen - tempStringLen, this.getHeight() - 10);
    }

    private void drawVersionNumber(Graphics2D g2d, Font font) {
        g2d.setFont(new Font(font.getName(), Font.BOLD, 16));
        g2d.drawString("v" + Version, 10, this.getHeight() - 10);
    }

    private void render() {
        BufferStrategy bs = this.getBufferStrategy();
        if (bs == null) {
            createBufferStrategy(3);
            return;
        }

        Graphics2D g2d = (Graphics2D) bs.getDrawGraphics();
        /* DRAW EVERYTHING BELOW HERE */

        // BACKGROUND
        g2d.setColor(Color.WHITE);
        g2d.fillRect(0, 0, WIDTH * SCALE, HEIGHT * SCALE);

        if (state == State.MENU || state == State.OPTIONS || state == State.EXTRAS || state == State.ARMORY || state == State.CREDITS) {
            // draw menu
            menu.render(g2d);

            g2d.setColor(Color.WHITE);
            drawFPS(g2d, sizedFont);
            drawVersionNumber(g2d, sizedFont);

        } else if (state == State.GAME) {
            // draw GameObjects
            h.render(g2d);
            //draw HUD
            hud.render(g2d);

            // draw Pause
            if (tick == false) {
                drawPause(g2d, sizedFont);
            }

            g2d.setColor(Color.BLACK);
            drawFPS(g2d, sizedFont);
            drawVersionNumber(g2d, sizedFont);

            // line between mouse and player
//          g2d.setColor(Color.GREEN);
//          g2d.draw(new Line2D.Double(this.h.getPlayer().getX() + SpriteSheet.SIZE * Game.SCALE / 2, this.h.getPlayer().getY() + SpriteSheet.SIZE * Game.SCALE / 2, mi.getMx() , mi.getMy()));
        }


        /* DRAW EVERYTHING ABOVE HERE */

        g2d.dispose();
        bs.show();
    }

    public void run() {
        this.requestFocus();
        init();
        long lastTime = System.nanoTime();
        double amountOfTicks = 60.0;
        double ns = 1000000000 / amountOfTicks;
        double delta = 0;
        int updates = 0;
        int frames = 0;
        long timer = System.currentTimeMillis();
        while (running) {
            long now = System.nanoTime();
            delta += (now - lastTime) / ns;
            lastTime = now;
            while (delta >= 1) {
                if (tick == true) {
                    tick();
                    updates++;
                }
                delta--;
            }
            render();
            frames++;

            if (System.currentTimeMillis() - timer > 1000) {
                fps = frames;
                ticks = updates;
                timer += 1000;
                System.out.println("=====================================");
                System.out.println("FPS: " + frames + " TICKS: " + updates);
                System.out.println("Game State: " + state);
                System.out.println("Number of bullets at the screen this moment: " + h.getBullets().size());
                System.out.println("Menu Position: " + menu.getMenuPosition());
                System.out.println("Armory Position X: " + menu.getArmoryPositionX());
                System.out.println("Armory Position Y: " + menu.getArmoryPositionY());
                System.out.println("=====================================");
                frames = 0;
                updates = 0;
            }
        }
        stop();
    }

    public static void main(String[] args) {
        new Game().start();
    }
}