using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;
using Lift_Controller;

namespace Event_Generator
{
    public class Geometric
    {
        public Geometric(double m)
        {
            mean = m;
            randomNumbers = new Random();
        }

        public int drawNext()
        {
            double p = 1/mean;
            int i = 0;
            do
            {
                double randval = randomNumbers.NextDouble();

                if (randval < p)
                {
                    break;
                }
                i++;
            } while (true);

            return i;
        }

        public double Mean
        {
            set { mean = value; }
        }

        private double mean;
        private Random randomNumbers;

    } // end class Geom


    public enum LiftEventType
    {
        FloorButtonEvent, LiftButtonEvent
    }

    public enum Direction
    {
        Up, Down, NotSpecified
    }

    public delegate void liftEventHandler(LiftEventState state);

    public class LiftEventState
    {

        public LiftEventState() {}
       
        public void liftEventStateChange(LiftEventType type, Direction d, int f, DateTime eTime)
        {
            liftEvType = type;
            dir = d;
            floor = f;
            eventTime = eTime;

            // Fire new lift event event
            newLiftEvent(this);
        }

        public override string ToString()
        {
            if (liftEvType == LiftEventType.FloorButtonEvent)
                Console.WriteLine("Floor button event ");
            else
                Console.WriteLine("Lift button event ");

            if (dir == Direction.Up)
                Console.WriteLine("Up");
            else
                Console.WriteLine("Down");

            Console.WriteLine("Floor " + floor);

            return base.ToString();
        }

        public LiftEventType LiftEvType
        {
            get { return liftEvType; }
        }

        public Direction Dir
        {
            get { return dir; }
        }

        public int Floor
        {
            get { return floor; }
        }

        public DateTime EventTime
        {
            get { return eventTime; }
        }

        
        public event liftEventHandler NewLiftEvent
        {
            add
            {
                newLiftEvent += value;
            }

            remove
            {
                newLiftEvent -= value;
            }
        }

        private event liftEventHandler newLiftEvent;
        private LiftEventType liftEvType;
        private Direction dir;
        private int floor=-1;
        private DateTime eventTime;
    }


    public class LiftEventGenerator
    {
        public LiftEventGenerator(int nf, double meanEventTime, LiftEventState state)
        {
            geom = new Geometric(meanEventTime);
            uniformRandomNumbers = new Random();
            numberOfFloors = nf;
            floor = -1;
            timer = new Timer();
            int t = geom.drawNext();
            timer.Elapsed += new ElapsedEventHandler(myTimerEventHandler);
            timer.Interval = timer.Interval = (1 + 1000 * t);

            // Initialize lift thread
            liftEventThread = new System.Threading.Thread(new System.Threading.ThreadStart(startLiftEvents));
            liftEventThread.Start();

            // Initialize lift event handler
            liftEvState= state;

            // First lift event is a floor button press
            liftEventType = LiftEventType.FloorButtonEvent;
        }

        public void startLiftEvents()
        {
            pause();
            run();
        }

        public void start()
        {
            timer.Start();
        }

        public void pause()
        {
            timer.Stop();
        }

        public void run()
        {
            lock (this)
            {
                System.Threading.Monitor.Wait(this);
            }
        }

        public double MeanEventTime
        {
            set { geom.Mean = value; }
        }

 
        public void myTimerEventHandler(object sender, ElapsedEventArgs eArgs)
        {
            // Randomly generate event state information
            if (sender == timer)
            {
                double t;

                // Event type
                double randval;
         
                // Direction
                direction=Direction.NotSpecified;               

                // Floor
                int prevFloor = floor;
                do
                {
                    randval = uniformRandomNumbers.NextDouble();
                    floor = (int)(randval * numberOfFloors);
                } while (floor == prevFloor);

                if (floor==numberOfFloors)
                    floor--; 

                if (liftEventType == LiftEventType.FloorButtonEvent)
                {
                    if (floor == 0)
                        direction = Direction.Up;
                    else if (floor == (numberOfFloors - 1))
                        direction = Direction.Down;
                    else
                    {
                        randval = uniformRandomNumbers.NextDouble();
                        if (randval < 0.5)
                            direction = Direction.Up;
                        else
                            direction = Direction.Down;
                    }
                }
                else if (liftEventType == LiftEventType.LiftButtonEvent)
                {
                }

                liftEvState.liftEventStateChange(liftEventType, direction, floor, eArgs.SignalTime);

                t = geom.drawNext();

                // Switch between event types
                if (liftEventType == LiftEventType.FloorButtonEvent)
                {
                    liftEventType = LiftEventType.LiftButtonEvent;

                    // Lift button event generated  after arriving at new floor
                    t = 6.0;        // Ensures arrival at floor before button press
                }
                else
                {
                    liftEventType = LiftEventType.FloorButtonEvent;
                    t = geom.drawNext();
                } 

                // t seconds to next event
                timer.Interval = (int)(1 + 1000 * t);

            }
        }

        public void closeEventThread()
        {
            liftEventThread.Abort();
        }

        private System.Threading.Thread liftEventThread;

        private LiftEventType liftEventType;

        private LiftEventState liftEvState;

        private int floor, numberOfFloors;

        private Direction direction;

        private Timer timer;

        private Random uniformRandomNumbers;

        private Geometric geom;

    } // end class LiftEventGenerator


    class Event_Generator
    {
        static void Main(string[] args)
        {
            int meanEventTime = 0;

            int numberOfFloors = 0;

            Console.Write("Input the mean time between floor button events (seconds) : ");

            meanEventTime=Convert.ToInt32(Console.ReadLine());

            Console.Write("How many floors : ");

            numberOfFloors = Convert.ToInt32(Console.ReadLine());

            LiftEventGenerator liftEvenGen = new LiftEventGenerator(numberOfFloors, meanEventTime, null);

        }
    }
}