using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Сжатие_RLE
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// упаковка файла в архив
        /// </summary>
        /// <param name="fileSource">исходный файл</param>
        /// <param name="filePack">упакованный файл</param>
        /// <param name="err">
        /// код ошибки
        /// 0 - ошибок не возникло
        /// 1 - исходный файл для упаковки не найден
        /// 2 - архивный файл невозможно открыть для записи
        /// </param>


        // исходный массив
        byte[] GeneratedList = new byte[15];
        // упакованный массив
        byte[] PackedList = new byte[31];
        // буфер в ОЗУ
        List<byte> bt = new List<byte>();

        // позиция генерированного массива
        long Position = 0;
        // позиция генерированного массива
        byte Counter = 1;
        // позиция упакованного массива
        long PackPosition = 0;


        private void btnPack_Click(object sender, EventArgs e)
        {
            // длина исходного файла в байтах
            long len = GeneratedList.Length;
            // перебор байт в исходном файле
            if (Position < len)
            {
                byte b = GeneratedList[Position];
                // если буфер пустой, то добавить байт в буфер
                if (bt.Count == 0)
                {
                    bt.Add(b);
                }
                else
                {
                    if (b == bt[0])
                    {
                        Counter++;
                    }
                    else
                    {
                        //сброс в архив
                        PackedList[PackPosition] = Counter;
                        PackPosition++;
                        PackedList[PackPosition] = bt[0];
                        PackPosition++;

                        bt.Clear();
                        bt.Add(b);
                        Counter = 1;
                    }
                }


                Position++;

            }
            if (Position == len)
            {
                btnPack.Text = "Завершено";

                //сброс в архив
                PackedList[PackPosition] = Counter;
                PackedList[PackPosition + 1] = bt[0];

            }



            //Вывод данных
            string GeneratedString = "";
            for (int i = 0; i < 15; i++)
            {
                if (i == Position)
                {
                    GeneratedString += "_" + GeneratedList[i].ToString() + "_" + " ";
                }
                else
                {
                    GeneratedString += GeneratedList[i].ToString() + " ";
                }

            }
            lblGenerate.Text = GeneratedString;


            GeneratedString = "";
            long LastShowPos = PackPosition;
            if (Position == len)
            {
                LastShowPos = PackPosition + 2;
            }
            for (int i = 0; i < LastShowPos; i++)
            {
                GeneratedString += PackedList[i].ToString() + " ";
            }
            lblPack.Text = GeneratedString;


            lblPosition.Text = "Позиция: " + Position.ToString();
            lblCounter.Text = "Счетчик: " + Counter.ToString();
            lblBuf.Text = "Буфер: " + bt[0].ToString();



            //while (Position < len)
            //{
            //    // прочитать из исходного файла очередной байт
            //    byte b = GeneratedList[Position];
            //    // если буфер пустой, то добавить байт в буфер
            //    if (bt.Count == 0)
            //        bt.Add(b);
            //    else  // если в буфере что-то есть
            //    {
            //        // если прочитанный байт не совпадает с последним байтом в буфере
            //        if (b != bt.Last())
            //        {
            //            bt.Add(b);  // добавить прочитанный байт в буфер
            //            // если в буфере накопилось 255 байт
            //            if (bt.Count == 255)
            //            {
            //                //bw.Write((byte)0);
            //                PackedList[PackPosition] = (byte)0;
            //                PackPosition++;

            //                //bw.Write((byte)255);
            //                PackedList[PackPosition] = (byte)255;
            //                PackPosition++;

            //                // bw.Write(bt.ToArray(), нач, кол-во);
            //                //bw.Write(bt.ToArray(), 0, bt.Count);
            //                for(int i=0; i<bt.Count; i++)
            //                {
            //                    PackedList[PackPosition] = bt[i];
            //                    PackPosition++;
            //                }
            //                bt.Clear();
            //            }
            //        }
            //        else  // т.е., если прочитанный байт совпадает с последним байтом в буфере
            //        {
            //            // если в буфере только один байт, то это последний байт из цепочки повторяющихся
            //            if (bt.Count > 1)
            //            {
            //                // вывести в архивный файл 0 и длину цепочки без повторов
            //                //bw.Write((byte)0);
            //                PackedList[PackPosition] = (byte)0;
            //                PackPosition++;

            //                //bw.Write((byte)(bt.Count - 1));
            //                PackedList[PackPosition] = (byte)(bt.Count - 1);
            //                PackPosition++;

            //                // вывести в архивный файл содержимое буфера от 0 до предпоследнего байта
            //                //bw.Write(bt.ToArray(), 0, bt.Count - 1);
            //                for (int i = 0; i < bt.Count; i++)
            //                {
            //                    PackedList[PackPosition] = bt[i];
            //                    PackPosition++;
            //                }

            //                // удалить в буфере все элементы от 0 до предпоследнего
            //                bt.RemoveRange(0, bt.Count - 1);
            //            }
            //            bt.Add(b);  // добавить в буфер текущий байт

            //            // если файл не закончился
            //            if (Position < len)
            //            {
            //                // пока прочитанный байт равен последнему байту в буфере
            //                //while ((b = br.ReadByte()) == bt.Last())
            //                while (((b = GeneratedList[Position + 1]) == bt.Last()))
            //                {
            //                    Position++;
            //                    bt.Add(b);  // добавить байт в буфер
            //                    // в буфере накопилось 255 одинаковых байт
            //                    if (bt.Count == 255)
            //                    {
            //                        // вывести кол-во повторяющихся байт
            //                        //bw.Write((byte)255);
            //                        PackedList[PackPosition] = (byte)255;
            //                        PackPosition++;

            //                        //bw.Write(b);  // вывести повторяющийся байт
            //                        PackedList[PackPosition] = b;
            //                        PackPosition++;

            //                        bt.Clear();  // очистить буфер
            //                        break;  // выйти из цикла
            //                    }
            //                    // если байты в файле закончились, то выйти из цикла
            //                    if (Position == len)
            //                        break;
            //                }
            //            }

            //            // если буфер не пустой (т.е. в нем есть повторяющиеся байты кол-вом менее 255)
            //            if (bt.Count > 0)
            //            {
            //                // вывести длину цепочки с повторами и сам повторяющийся байт
            //                //bw.Write((byte)bt.Count);
            //                PackedList[PackPosition] = (byte)bt.Count;
            //                PackPosition++;

            //                //bw.Write(bt.Last());
            //                PackedList[PackPosition] = bt.Last();
            //                PackPosition++;

            //                bt.Clear();  // очистить буфер
            //                // если еще не дошли до конца файла, добавить текущий байт в буфер
            //                if (Position < len)
            //                    bt.Add(b);
            //            }
            //        }
            //    }
            //}

            //// === ЗАКОНЧИЛСЯ ПЕРЕБОР БАЙТ В ИСХОДНОМ ФАЙЛЕ ===
            //// если после перебора байт в буфере что-то есть, то это будет цепочка байт без повтора
            //if (bt.Count > 0)
            //{
            //    //bw.Write((byte)0);
            //    PackedList[PackPosition] = (byte)0;
            //    PackPosition++;

            //    //bw.Write((byte)bt.Count);
            //    PackedList[PackPosition] = (byte)bt.Count;
            //    PackPosition++;

            //    //bw.Write(bt.ToArray(), 0, bt.Count);

            //}
        }

        private void btnUnPack_Click(object sender, EventArgs e)
        {
            openFile.Filter = "Архивные файлы|*.pack|Все файлы|*.*";

            if (openFile.ShowDialog() == DialogResult.OK)
            {
                //UnPack(openFile.FileName);

                MessageBox.Show("Распаковка файла из архива закончена", "Внимание!", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }

        private void btnGenerate_Click(object sender, EventArgs e)
        {
            Random RND = new Random();

            //заполняем случайными числами
            for (int i = 0; i < 12; i++)
            {
                GeneratedList[i] = (byte)(RND.Next());

                // дополняем повторениями
                if ((GeneratedList[i] % 2) == 0)
                {
                    GeneratedList[i + 1] = GeneratedList[i];
                    i++;
                }
                if ((GeneratedList[i] % 3) == 0)
                {
                    GeneratedList[i + 1] = GeneratedList[i];
                    GeneratedList[i + 2] = GeneratedList[i];
                    i++;
                    i++;
                }
            }



            //выводим на форму
            string GeneratedString = "";
            for (int i = 0; i < 15; i++)
            {
                GeneratedString += GeneratedList[i].ToString() + " ";
            }
            lblGenerate.Text = GeneratedString;



        }
    }
}