using System;
using System.Collections;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace ApiProcessToken.Models.common
{
   
    public class Queue
    {
        private int maxQueueSize = 0;
        private ArrayList queueData = new ArrayList();
        private object mutex;

      
        public Queue()
        {
            maxQueueSize = 1000000;
            mutex = this;
        }

   
        public Queue(int maxSize)
        {
            maxQueueSize = maxSize;
            mutex = this;
        }

    
        public int Size()
        {
            lock (mutex)
            {
                return queueData.Count;
            }
        }



        public bool IsEmpty()
        {
            lock (mutex)
            {
                return (queueData.Count == 0);
            }
        }


   
        public object Dequeue()
        {
            lock (mutex)
            {
                object first = null;
                if (queueData.Count > 0)
                {
                    first = queueData[0];
                    queueData.RemoveAt(0);
                }
                return first;
            }
        }




        public object Dequeue(object obj)
        {
            object found = null;
            lock (mutex)
            {
                found = queueData.Contains(obj);
                if (found != null)
                {
                    queueData.Remove(obj);
                }
            }
            return obj;
        }



   
        public void Enqueue(Object obj)
        {
            lock (mutex)
            {
                if (queueData.Count >= maxQueueSize)
                {
                    throw new IndexOutOfRangeException("Queue is full. Element not added.");
                }
                queueData.Add(obj);
            }
        }

        public void Clear()
        {
            lock (mutex)
            {
                if (queueData.Count >= 0)
                {
                    queueData.Clear();
                }
            }
        }

 
        public object Find(object obj)
        {
            lock (mutex)
            {
                object current;
                IEnumerator iter = queueData.GetEnumerator();
                while (iter.MoveNext())
                {
                    current = iter.Current;
                    if (current.Equals(obj))
                    {
                        return current;
                    }
                }
            }
            return null;
        }

        public ArrayList ToArrayList()
        {
            return queueData;
        }

        public ArrayList ToArrayListAndClear()
        {
            lock (mutex)
            {
                ArrayList result = new ArrayList();
                if (queueData.Count >= 0)
                {
                    result.AddRange(queueData);
                    queueData.Clear();
                }
                return result;
            }
        }

   
        public void SaveQueue(string file_name)
        {
            if (File.Exists(file_name))
            {
                File.Delete(file_name);
            }
            Stream st = File.Create(file_name);
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(st, queueData);
            st.Close();
        }

        public int LoadQueue(string file_name)
        {
            if (File.Exists(file_name))
            {
                Stream st = File.OpenRead(file_name);
                if (st.Length > 0)
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    queueData = (ArrayList)bf.Deserialize(st);
                }
                st.Close();
                //File.Delete(file_name);
            }
            return queueData.Count;
        }
    }
}