using System;
using System.Threading;
using OpenTK.Mathematics;
using OpenTK.Windowing.Desktop;
using OpenTK.Windowing.GraphicsLibraryFramework;

namespace TheBountyHunter
{
    public partial class PlottingWindow : GameWindow
    {
        Plot Price;
        Plot Derivative;
        Plot Expectation;
        Plot Total;
        Plot Cash;
        Plot Property;
        Plot Multiplier;

        bool timePassing = true;

        float time = 0;
        int Scale = 100;
        
        int interval = 50;
        
        float property = 0;
        float cash = 100;

        float price = 100;
        float prev = 0;

        float derivative = 0;
        float expectation = 0;

        float multiplier = 1;
        float aggressiveness = 5;

        private void Begin()
        {            
            Price = new Plot(200, Width);
            Total = new Plot(200, Width);
            Expectation = new Plot(200, Width);
            
            Cash = new Plot(200, Width, false);
            Property = new Plot(0, Width, false);
            
            Derivative = new Plot(0.5f, Width, false);
            Multiplier = new Plot(5, Width, false);

            new Thread(() =>
            {
                while(true)
                {
                    Thread.Sleep(interval);
                    if(timePassing)
                    {
                        Hunt();
                    }
                    Title = $"White Price: {price} Green (C)ash: {cash} Yellow (D)erivative: {derivative} Blue (P)roperty: {property} Red (T)otal: {property * price + cash} Grey (M)ultiplier: {multiplier} Brown (E)xpectation {expectation}";
                }
            }).Start();
        }

        void Hunt()
        {
            derivative = (price - prev) / interval;
            
            expectation = price + derivative * interval;

            prev = price;

            if(derivative == 0)
            {
                multiplier = Math.Max(1, multiplier - aggressiveness * ((property * price + cash) / 100) * interval);
                return;
            }

            multiplier += interval * (aggressiveness / 100) * (property * price + cash);

            if(derivative > 0)
            {
                Buy(ref cash, multiplier * Math.Abs(derivative));
            }
            else
            {
                Sell(ref cash, multiplier * Math.Abs(derivative));
            }
        }
        
        void Buy(ref float money, float investment)
        {
            if(money - investment >= 0)
            {
                property += investment / price;
                money -= investment;
            }
            else 
            {
                property += money / price;
                money = 0;
            }
        }

        void Sell(ref float money, float investment)
        {
            if((property - (investment / price)) >= 0)
            {
                property -= investment / price;
                money += investment;
            }
            else
            {
                money += property * price;
                property = 0;
            }
        }

        private void Input(float delta)
        {
            if(KeyboardState.IsKeyReleased(Keys.Tab))
                timePassing = !timePassing;
            if(KeyboardState.IsKeyDown(Keys.Up) && timePassing)
                price++;
            if(KeyboardState.IsKeyDown(Keys.Down) && price - 1 > 0 && timePassing)
                price--;
            if(KeyboardState.IsKeyReleased(Keys.C))
                Cash.Enabled =! Cash.Enabled;
            if(KeyboardState.IsKeyReleased(Keys.P))
                Property.Enabled =! Property.Enabled;
            if(KeyboardState.IsKeyReleased(Keys.T))
                Total.Enabled =! Total.Enabled;
            if(KeyboardState.IsKeyReleased(Keys.D))
                Derivative.Enabled =! Derivative.Enabled;
            if(KeyboardState.IsKeyReleased(Keys.E))
                Expectation.Enabled =! Expectation.Enabled;
            if(KeyboardState.IsKeyReleased(Keys.M))
                Multiplier.Enabled =! Multiplier.Enabled;
        }

        private void Update(float delta)
        {
            time += delta * 50;

            if(timePassing)
            {
                Price.Update(delta);
                Derivative.Update(delta);
                Total.Update(delta);
                Cash.Update(delta);
                Property.Update(delta);
                Multiplier.Update(delta);
                Expectation.Update(delta);
            }
        }

        private void Draw(ref Canvas screen)
        {
            for (int i = 0; i < Height; i += Height / Scale * 2)
            {
                screen.FastDrawLine(new Color4(0.1f, 0.1f, 0.1f, 1f), 0, Width, i);
            }
            
            screen.FastDrawLine(new Color4(0.1f, 0.1f, 0.1f, 1f), 0, Width, Height / 2);
            
            for (int i = 0; i < Width; i += Width / Scale * 1)
            {
                screen.DrawLine(new Vector2i(i, 0), new Vector2i(i, Width), new Color4(0.1f, 0.1f, 0.1f, 1f));
            }

            if(timePassing)
            {
                Price.Add(price);
                Derivative.Add(derivative);
                Total.Add(property * price + cash);
                Cash.Add(cash);
                Property.Add(property);
                Multiplier.Add(multiplier);
                Expectation.Add(expectation);
            }

            Expectation.Render(ref screen, Color4.Brown);
            Derivative.Render(ref screen, Color4.Yellow);
            Multiplier.Render(ref screen, Color4.Gray);
            Property.Render(ref screen, Color4.Blue);
            Cash.Render(ref screen, Color4.Green);
            Total.Render(ref screen, Color4.Red);
            Price.Render(ref screen, Color4.White);
        }
    }
}