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 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;
            timer = new Timer();
            int i = geom.drawNext();
            Console.WriteLine("i= " + i);
            timer.Elapsed += new ElapsedEventHandler(myTimerEventHandler);
            timer.Interval = timer.Interval = (1 + 1000 * i);

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

            // Initialize lift event handler
            liftEvState= state;
        }

        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)
        {
            if (sender == timer)
            {
                // Randomly generate event state information

                // Event type
                double randval = uniformRandomNumbers.NextDouble();
                if (randval < 0.5)
                    liftEventType = LiftEventType.FloorButtonEvent;
                else
                    liftEventType = LiftEventType.LiftButtonEvent;

                // Direction
                direction=Direction.NotSpecified;               

                // Floor
                randval = uniformRandomNumbers.NextDouble();
                floor = (int)(randval * numberOfFloors);

                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;
                    }
                }

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

                int t = geom.drawNext();

                // t seconds to next event
                timer.Interval = (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);

        }
    }
}