using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.Json;

namespace ConvertLog.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)
        {
            // Chỉ lưu những phần tử đúng kiểu oneImportObj (đang được sử dụng trong project)
            var typedList = new List<oneImportObj>();
            foreach (var item in queueData)
            {
                if (item is oneImportObj obj)
                {
                    typedList.Add(obj);
                }
            }

            var options = new JsonSerializerOptions
            {
                WriteIndented = false
            };

            string json = JsonSerializer.Serialize(typedList, options);
            File.WriteAllText(file_name, json);
        }

        public int LoadQueue(string file_name)
        {
            if (File.Exists(file_name))
            {
                string json = File.ReadAllText(file_name);
                if (!string.IsNullOrWhiteSpace(json))
                {
                    var list = JsonSerializer.Deserialize<List<oneImportObj>>(json) ?? new List<oneImportObj>();

                    lock (mutex)
                    {
                        queueData.Clear();
                        foreach (var item in list)
                        {
                            queueData.Add(item);
                        }
                    }
                }
            }
            return queueData.Count;
        }

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