package com.gurniak.accelerometer.test;

import java.util.Arrays;
import java.util.Calendar;
import java.util.Random;

import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.TimeUtils;

public class Accelerometer_Test implements ApplicationListener {
    private static final String TAG = "AccelerometerTest";

    private final int SCREEN_WIDTH = 800;
    private final int SCREEN_HEIGHT = 480;
    private final int MAX_NUM_POINTS = 500;

    private OrthographicCamera camera;
    private ShapeRenderer shapeRenderer;
    private Array<Vector2> pointsX;

    private float[] verticesX;

    @Override
    public void create() {
        camera = new OrthographicCamera();
        camera.setToOrtho(false, SCREEN_WIDTH, SCREEN_HEIGHT);
        shapeRenderer = new ShapeRenderer();
        pointsX = new Array<Vector2>();

        updateChart(Gdx.input.getAccelerometerX(), pointsX);
    }

    @Override
    public void render() {
        Gdx.gl.glClearColor(0.2f, 0.2f, 0.2f, 1);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

        Gdx.gl20.glLineWidth(3);

        camera.update();
        shapeRenderer.setProjectionMatrix(camera.combined);

        // Drawing chart

        shapeRenderer.begin(ShapeType.Line);

        shapeRenderer.setColor(1, 0, 0, 1);

        if (pointsX.size > 1) {
            shapeRenderer.polyline(verticesX);
        }

        shapeRenderer.end();

        // Updating chart

        if(pointsX.size < MAX_NUM_POINTS) {
            updateChart(Gdx.input.getAccelerometerX(), pointsX);
        }

        if (pointsX.size > 1) {
            verticesX = getVertices(pointsX);
        }

    }

    // Transforms Array of Vector2 (x,y) into float[] array of points [x,y,x,y...]
    private float[] getVertices(Array<Vector2> points) {
        float[] result = new float[points.size * 2];
        int indeks = 0;

        for (int i = 0; i < result.length; i++) {
            if (i % 2 == 0) {
                result[i] = points.get(indeks).x;
            } else {
                result[i] = points.get(indeks).y;
                indeks++;
            }
        }

        return result;
    }

    // recalculates X values of points
    private void updateChart(float newValue, Array<Vector2> points) {
        newValue = (newValue * 10) + SCREEN_HEIGHT / 2;

        if (points.size <= 1) {
            points.add(new Vector2(0, newValue));
        } else {
            if (points.size < MAX_NUM_POINTS) {
                int step = (int) Math.ceil(SCREEN_WIDTH / ((points.size - 1) * 1.0));

                points.add(new Vector2(0, newValue));

                for (int i = 0; i < points.size; i++) {
                    points.get(i).x = (i * step);
                }

                if (points.get(points.size - 1).x != SCREEN_WIDTH) {
                    points.get(points.size - 1).x = SCREEN_WIDTH;
                }

            }
        }
    }

    @Override
    public void dispose() {
        shapeRenderer.dispose();
        pointsX.clear();
    }

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }
}