import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferStrategy;

public class Game extends javax.swing.JFrame {

    private static final long serialVersionUID = 1L;
    /* difference between time of update and world step time */
    double localTime = 0f;

    /** Creates new form Game */
    public Game() {
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setIgnoreRepaint(true);
        this.setSize(800, 600);
    }

    /**
     * Starts the game loop in a new Thread.
     * @param fixedTimeStep
     * @param maxSubSteps maximum steps that should be processed to catch up with real time.
     */
    public final void start(final double fixedTimeStep, final int maxSubSteps) {

            this.createBufferStrategy(2);
        init();
        long start = System.nanoTime();
        long step=(long)Math.floor(1000000000d * fixedTimeStep);        
        while (true) {
            long now = System.nanoTime();
            double elapsed = (now - start) / 1000000000d;
            start = now;
            internalUpdateWithFixedTimeStep(elapsed, maxSubSteps, fixedTimeStep);
            internalUpdateGraphicsInterpolated();
            while (true) {         
                Thread.yield();
                long delta = start + step - System.nanoTime();
                if (delta <= 0) {
                    break;
                }                
                try {
                    Thread.sleep(1);
                } catch (InterruptedException ex) {
                }
            }
        }
    }

    /**
     * Updates game state if possible and sets localTime for interpolation.
     * @param elapsedSeconds
     * @param maxSubSteps
     * @param fixedTimeStep 
     * @return count of processed fixed timesteps
     */
    private int internalUpdateWithFixedTimeStep(double elapsedSeconds, int maxSubSteps, double fixedTimeStep) {
        int numSubSteps = 0;
        if (maxSubSteps != 0) {
            // fixed timestep with interpolation
            localTime += elapsedSeconds;
            if (localTime >= fixedTimeStep) {
                numSubSteps = (int) (localTime / fixedTimeStep);
                localTime -= numSubSteps * fixedTimeStep;
            }
        }
        if (numSubSteps != 0) {
            // clamp the number of substeps, to prevent simulation grinding spiralling down to a halt
            int clampedSubSteps = (numSubSteps > maxSubSteps) ? maxSubSteps : numSubSteps;
            for (int i = 0; i < clampedSubSteps; i++) {
                update(fixedTimeStep);
            }
            return clampedSubSteps;
        }
        return 0;
    }

    /**
     * Calls render with Graphics2D context and takes care of double buffering.
     */
    private void internalUpdateGraphicsInterpolated() {
        BufferStrategy bf = this.getBufferStrategy();
        
        Graphics2D g = null;
        try {
            g = (Graphics2D) bf.getDrawGraphics();
            render(g, localTime);
        } finally {
            g.dispose();
        }
        // Shows the contents of the backbuffer on the screen.
        bf.show();        
        //Tell the System to do the Drawing now, otherwise it can take a few extra ms until 
        //Drawing is done which looks very jerky
        Toolkit.getDefaultToolkit().sync();
    }
    Ball[] balls;
    BasicStroke ballStroke;
    int showMode = 0;

    /**
     * init Game (override/replace)
     */
    protected void init() {
        balls = new Ball[20];
        int r = 20;
        for (int i = 0; i < balls.length; i++) {
            Ball ball = new Ball(getWidth() / 2, (getHeight() - 120) / (balls.length + 1f) * (i + 1f) + 60f, 10f + i * 300f / balls.length, 0, r);
            balls[i] = ball;
        }
        ballStroke = new BasicStroke(3);
        this.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                showMode = ((showMode + 1) % 3);
            }
        });
    }

    /**
     * update game. elapsedTime is fixed.
     * @param elapsedTime 
     */
    protected void update(double elapsedTime) {
        for (Ball ball : balls) {
            ball.x += ball.vX * elapsedTime;
            ball.y += ball.vY * elapsedTime;
            if (ball.x > getWidth() - ball.r) {
                ball.vX *= -1;
            }
            if (ball.x < ball.r) {
                ball.vX *= -1;
            }

            if (ball.y > getHeight() - ball.r) {
                ball.vY *= -1;
            }
            if (ball.y < ball.r) {
                ball.vY *= -1;
            }
        }
    }

    /**
     * render the game
     * @param g
     * @param interpolationTime time of the rendering within a fixed timestep (in seconds)
     */
    protected void render(Graphics2D g, double interpolationTime) {
        g.clearRect(0, 0, getWidth(), getHeight());
        if (showMode == 0) {
            g.drawString("red: raw, black: interpolated (click to switch modes)", 20, 50);
        }
        if (showMode == 1) {
            g.drawString("red: raw (click to switch modes)", 20, 50);
        }
        if (showMode == 2) {
            g.drawString("black: interpolated (click to switch modes)", 20, 50);
        }
        for (Ball ball : balls) {
            g.setStroke(ballStroke);
            if (showMode == 0 || showMode == 1) {
                //w/o interpolation
                g.setColor(Color.RED);
                g.drawOval((int) (ball.x - ball.r), (int) (ball.y - ball.r), (int) ball.r * 2, (int) ball.r * 2);
            }
            if (showMode == 0 || showMode == 2) {
                //with interpolation
                g.setColor(Color.BLACK);
                g.drawOval((int) (ball.x - ball.r + interpolationTime * ball.vX), (int) (ball.y - ball.r + interpolationTime * ball.vY), (int) ball.r * 2, (int) ball.r * 2);
            }
        }
    }

    public static class Ball {

        public double x, y, vX, vY, r;

        public Ball(double x, double y, double vX, double vY, double r) {
            this.x = x;
            this.y = y;
            this.vX = vX;
            this.vY = vY;
            this.r = r;
        }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Create and display the form */
        new Thread() {

            {
                setDaemon(true);
                start();
            }

            public void run() {
                while (true) {
                    try {
                        Thread.sleep(Integer.MAX_VALUE);
                    } catch (Throwable t) {
                    }
                }
            }
        };
        Game game = new Game();
        game.setVisible(true);
        game.start(1 / 120d, 5);
    }
}

public void run() {
      if (myGame != null) myGame.initGame();
      
      //This value would probably be stored elsewhere.
      //final double GAME_HERTZ = 30.0;
      //Calculate how many ns each frame should take for our target game hertz.
      final double TIME_BETWEEN_UPDATES = 1000000000.0 / gameSpeed;//GAME_HERTZ;
      //At the very most we will update the game this many times before a new render.
      final int MAX_UPDATES_BEFORE_RENDER = 5;
      //We will need the last update time.
      double lastUpdateTime = System.nanoTime();
      //Store the last time we rendered.
      double lastRenderTime = System.nanoTime();
      
      //If we are able to get as high as this FPS, don't render again.
      final double TARGET_FPS = 60;
      final double TARGET_TIME_BETWEEN_RENDERS = 1000000000 / TARGET_FPS;
      
      //Simple way of finding FPS.
      int lastSecondTime = (int) (lastUpdateTime / 1000000000);
      
      running = true;
      
      while (running) {
         double now = System.nanoTime();//*/
         int updateCount = 0;
         
         //Do as many game updates as we need to, potentially playing catchup.
         while(now - lastUpdateTime > TIME_BETWEEN_UPDATES && updateCount < MAX_UPDATES_BEFORE_RENDER) {
            update();
            lastUpdateTime += TIME_BETWEEN_UPDATES;
            updateCount++;
            updatesPerSecondCount++;//
         }
         
         //If for some reason an update takes forever, we don't want to do an insane number of catchups.
         //If you were doing some sort of game that needed to keep EXACT time, you would get rid of this.
         if (now - lastUpdateTime > TIME_BETWEEN_UPDATES) {
            lastUpdateTime = now - TIME_BETWEEN_UPDATES;
         }
         
         debugDisplay = "" + updateCount;//
         
         //Render. To do so, we need to calculate interpolation for a smooth render.
         interpolation = Math.min(1.0f, (float) ((now - lastUpdateTime) / TIME_BETWEEN_UPDATES));
         render();
         lastRenderTime = now;
         
         //Update the frames we got.
         int thisSecond = (int) (lastUpdateTime / 1000000000);
         if (thisSecond > lastSecondTime) {
            fps = frameCount;
            frameCount = 0;
            updatesPerSecond = updatesPerSecondCount;//
            updatesPerSecondCount = 0;//
            lastSecondTime = thisSecond;
         }
         
         //Yield until it has been at least the target time between renders. This saves the CPU from hogging.
         while (now - lastRenderTime < TARGET_TIME_BETWEEN_RENDERS && now - lastUpdateTime < TIME_BETWEEN_UPDATES) {
            Thread.yield();
            
            //This stops the app from consuming all your CPU. It makes this slightly less accurate, but is worth it.
            //You can remove this line and it will still work (better), your CPU just climbs on certain OSes.
            //FYI on some OS's this can cause pretty bad stuttering.
            try {Thread.sleep(1);} catch(Exception e) {}
            
            now = System.nanoTime();
         }//*/
      }
   }
   
   public void update() {
      myInput.updateKeys();
      if (myGame != null) myGame.update();
   }
   
   public void render() {
      g = (Graphics2D) strategy.getDrawGraphics();
      g.scale(scale, scale);
      /*g.setColor(Color.LIGHT_GRAY);
      g.fillRect(0, 0, width, height);//*/
      if (myGame != null) myGame.render();
      if (debugOn) {
         g.setColor(Color.BLACK);
         g.drawString("Interpolation: " + interpolation, 0, 16);
         g.drawString("FPS: " + fps, 0, 32);
         g.drawString("Updates per second: " + updatesPerSecond, 0, 48);
         g.drawString("updateCount: " + debugDisplay, 0, 64);
      }
      frameCount++;
      g.dispose();
      strategy.show();
   }

@Override
    public void update(GameContainer container, int delta)
            throws SlickException {
      double now = Sys.getTime() * 1000000000.0 / Sys.getTimerResolution();//*/
      int updateCount = 0;
      
      //Do as many game updates as we need to, potentially playing catchup.
      while(now - lastUpdateTime > timeBetweenUpdates && updateCount < maxUpdatesBeforeRender) {
         innerUpdate();
         lastUpdateTime += timeBetweenUpdates;
         updateCount++;
         updatesPerSecondCount++;//
      }
      
      //If for some reason an update takes forever, we don't want to do an insane number of catchups.
      //If you were doing some sort of game that needed to keep EXACT time, you would get rid of this.
      if (now - lastUpdateTime > timeBetweenUpdates) {
         lastUpdateTime = now - timeBetweenUpdates;
      }

      interpolation = Math.min(1.0f, (float) ((now - lastUpdateTime) / timeBetweenUpdates));      
      
       //Update the frames we got.
      int thisSecond = (int) (Sys.getTime() / Sys.getTimerResolution());
      if (thisSecond > lastSecondTime) {
         updatesPerSecond = updatesPerSecondCount;//
         updatesPerSecondCount = 0;//
         lastSecondTime = thisSecond;
      }
       
       deltaDisplay = delta;
    }
    
    public void innerUpdate() {
       for (int i = 0; i < positions.length; i++) {
         positions[i] += directions[i] * (SPEED * i + SPEED);
         if (positions[i] <= 0) directions[i] = 1;
         else if (positions[i] >= DEFAULT_WIDTH) directions[i] = -1;
      }

      for (int i = 0; i < positions.length; i++) {
         lastPositions[i] = positions[i];
      }//*/
    }

    @Override
    public void render(GameContainer container, Graphics g)
            throws SlickException {
       //double now = Sys.getTime() * 1000000000.0 / Sys.getTimerResolution();//*/
       g.scale(DEFAULT_SCALE, DEFAULT_SCALE);
        g.setColor(Color.lightGray);
      g.fillRect(0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT);//*/
      g.setColor(Color.red);
      for (int i = 0; i < positions.length; i++) {
         int x;
         if (drawInterpolated) {
            x = (int) ((positions[i] - lastPositions[i]) * interpolation + lastPositions[i]);
         } else {
            x = (int) positions[i];
         }
         for (int j = 0; j < 2; j++) {
            //g.fillRect(x, HEIGHTS[j] + 16 * i, 16, 16);
            sprite.draw(x, HEIGHTS[j] + 16 * i);
            //fonts[j].draw(":)", x, HEIGHTS[j] + 16 * i - 16);
         }
      }
      g.setColor(Color.white);
        g.drawString("Hello, Slick world!", 16, 100);
        g.drawString("Delta: " + deltaDisplay, 16, 116);
        g.drawString("Updates per second: " + updatesPerSecond, 16, 132);
        g.drawString("Sys.getTime(): " + Sys.getTime(), 16, 148);
        g.drawString("Sys.getTimerResolution(): " + Sys.getTimerResolution(), 16, 164);
        g.drawString("" + Sys.getTime() * 1000000000.0 / Sys.getTimerResolution(), 16, 180);
        g.drawString("Interpolation: " + interpolation, 16, 196);
        /*interpolation = Math.min(1.0f, (float) ((now - lastRenderTime) / timeBetweenUpdates));
        lastRenderTime = now;//*/
        /*for (int i = 0; i < positions.length; i++) {
         lastPositions[i] = positions[i];
      }//*/
    }

   public class Sync {
   
      private long timeThen;
      
      public Sync() {
         timeThen = Sys.getTime() & 0x7FFFFFFFFFFFFFFFL;
      }

      public void sync(int frameRate) {
         long timeNow = Sys.getTime() & 0x7FFFFFFFFFFFFFFFL;
         if (timeNow < timeThen) {
            // Account for clock wrapping
            timeThen = timeNow;
         }
         long timeNext = (timeThen + Sys.getTimerResolution() / frameRate) & 0x7FFFFFFFFFFFFFFFL;
         if (timeNext < timeNow) {
            // Just forget about it this frame, clock's wrapped
            timeThen = timeNow;
            return;
         }
         do {
            Thread.yield();
            timeNow = Sys.getTime() & 0x7FFFFFFFFFFFFFFFL;
         } while (timeNow < timeNext);
         timeThen = timeNext;
      }
   }