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

namespace racVec_naloga3
{
    public partial class Form1 : Form
    {
        byte[] buffer = null;
        short[] left = null;
        short[] right = null;
        short[] mid = null;
        short[] side = null;
        int read = 0;
        short[] sampleBuffer = null;
        string fileName = "";
        int frekvenca_vzorcenja = 0;

        public Form1()
        {
            InitializeComponent();
        }

        private void button_odpri_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();

            if(ofd.ShowDialog() == DialogResult.OK)
            {
                using (WaveFileReader reader = new WaveFileReader(ofd.FileName))
                {
                    frekvenca_vzorcenja = reader.WaveFormat.SampleRate;
                    buffer = new byte[reader.Length];
                    read = reader.Read(buffer, 0, buffer.Length);
                    sampleBuffer = new short[read / 2];
                    Buffer.BlockCopy(buffer, 0, sampleBuffer, 0, read);

                    left = new short[sampleBuffer.Length/2];
                    right = new short[sampleBuffer.Length / 2];

                    int k = 0;
                    for (int i = 0; i < sampleBuffer.Length; i += 2)
                    {
                        left[k] = sampleBuffer[i];
                        right[k] = sampleBuffer[i + 1];
                        k++;
                    }

                    mid = new short[sampleBuffer.Length / 2];
                    side = new short[sampleBuffer.Length / 2];

                    for (int i = 0; i < sampleBuffer.Length/2; i++)
                    {
                        mid[i] = (short)((left[i] + right[i]) / 2.0);
                        side[i] = (short)((left[i] - right[i]) / 2.0);
                    }

                    fileName = ofd.FileName;

                }
            }
        }

        private void button_predvajanje_Click(object sender, EventArgs e)
        {
            SoundPlayer player = new SoundPlayer(fileName);
            player.Play();
        }

        private void button_kompresija_Click(object sender, EventArgs e)
        {
            short[] buffer2 = new short[] { -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11};
            short[][] channels = new short[2][] { mid, side};
            //short[][] channels = new short[2][] { buffer2, buffer2 };
            int N = (int)numericUpDown_N.Value;
            int M = (int)numericUpDown_M.Value;

            List<int> seznam = new List<int>();

            //pisanje v datoteko - glava
            BinWriter writer = new BinWriter("out.bin");
            writer.writeValue(4 * 8, sampleBuffer.Length);
            //writer.writeValue(4 * 8, buffer2.Length);
            writer.writeValue(2 * 8, N);
            writer.writeValue(4 * 8, frekvenca_vzorcenja);
            writer.writeValue(2 * 8, M);

            for (int c=0; c<channels.Length; c++)
            {
                int st_okvirjev = (int)Math.Ceiling((decimal)((channels[c].Length*1.0) / (N*1.0))) + 1;
                List<List<double>> bloki = new List<List<double>>();
                for (int i = 0; i < st_okvirjev; i++)
                    bloki.Add(new List<double>());

                for (int i = 0; i < N; i++)
                {
                    bloki[0].Add(0);
                }

                //okenska funkcija
                List<double> okenska = new List<double>();
                for (int i = 0; i < 2 * N; i++)
                {
                    okenska.Add(Math.Sin((Math.PI / (2 * N)) * (i + 0.5)));
                }

                //razdelitev arraya na bloke
                int i_buffer = 0;
                for (int i = 0; i < st_okvirjev; i++)
                {
                    while (bloki[i].Count < 2 * N)
                    {
                        if (i_buffer < channels[c].Length)
                        {
                            bloki[i].Add(channels[c][i_buffer] * okenska[bloki[i].Count]);
                            i_buffer++;
                        }
                        else
                            bloki[i].Add(0);
                    }
                    i_buffer -= N;
                }

                //MDCT
                int[,] MTDC = new int[st_okvirjev, N];
                for (int i = 0; i < st_okvirjev; i++)
                {
                    for (int k = 0; k < N; k++)
                    {
                        double sestevek = 0;
                        for (int n = 0; n < 2 * N; n++)
                        {
                            sestevek += bloki[i][n] * Math.Cos(Math.PI / N * (n + 0.5 + (N / 2.0)) * (k + 0.5));
                        }
                        MTDC[i, k] = (int)Math.Round(sestevek);
                    }
                }

                //kvantizacija
                if (M > 0)
                {
                    for (int i = 0; i < st_okvirjev; i++)
                    {
                        for (int m = N - M; m < N; m++)
                        {
                            MTDC[i, m] = 0;
                        }
                    }
                }

                //pisanje v datoteko
                for(int i=0; i<st_okvirjev; i++)
                {
                    for(int j=0; j<N-M; j++)
                    {
                        int a = 5;
                        if (MTDC[i, j] == -2907)
                            a = 5;
                        int dolzina = 0;
                        if (MTDC[i, j] == 0)
                            dolzina = 2;
                        else if(Math.Log(Math.Abs(MTDC[i, j]), 2) == (int)Math.Log(Math.Abs(MTDC[i, j]), 2))
                            dolzina = (int)Math.Ceiling(Math.Log(Math.Abs(MTDC[i, j]), 2) + 2);
                        else
                            dolzina = (int)Math.Ceiling(Math.Log(Math.Abs(MTDC[i, j]), 2) + 1);
                        writer.writeValue(6, dolzina);
                        writer.writeValue(dolzina, MTDC[i,j]);
                        seznam.Add(MTDC[i, j]);
                    }
                }
            }

            writer.Closing();
        }

        private void label2_Click(object sender, EventArgs e)
        {

        }

        private void button_dekompresija_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            BinReader reader = null;
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                reader = new BinReader(ofd.FileName);
            }

            if(reader != null)
            {
                List<int> vrednosti = new List<int>();
                int st_vzorcev = 0;
                int N = 0;
                int sample_rate = 0;
                int M = 0;

                st_vzorcev = reader.readValue(4 * 8, false);
                N = reader.readValue(2 * 8, false);
                sample_rate = reader.readValue(4 * 8, false);
                M = reader.readValue(2*8, false);
                int g = 0;
                while (reader.file.Position < reader.file.Length)
                {
                    if (vrednosti.Count == 33542)
                        g = 0;
                    int dolzina = reader.readValue(6, false);
                    vrednosti.Add(reader.readValue(dolzina, true));
                }

                reader.file.Close();

                int[] MTDC_mid = new int[vrednosti.Count/2];
                int[] MTDC_side = new int[vrednosti.Count / 2];


                for(int i=0; i<vrednosti.Count/2; i++)
                {
                    MTDC_mid[i] = vrednosti[i];
                }
                for (int i = 0, j = vrednosti.Count / 2; i < vrednosti.Count / 2 && j < vrednosti.Count; i++, j++){
                    MTDC_side[i] = vrednosti[j];
                }

                short[] d_mid = new short[st_vzorcev/2];
                short[] d_side = new short[st_vzorcev / 2];

                int[][] MTDC_array = new int[2][] { MTDC_mid, MTDC_side };
                short[][] channels = new short[2][] {d_mid, d_side};
                for (int c=0; c< MTDC_array.Length; c++)
                {
                    int st_okvirjev = MTDC_array[c].Length / (N - M);
                    int[,] MTDC = new int[st_okvirjev, N];
                    int index = 0;
                    for(int i=0; i<st_okvirjev; i++)
                    {
                        for(int j=0; j<N; j++)
                        {
                            if (j < N - M)
                            {
                                MTDC[i, j] = MTDC_mid[index];
                                index++;
                            }
                            else
                                MTDC[i, j] = 0;
                        }
                    }

                    //okenska funkcija
                    double[] okenska = new double[2 * N];
                    for (int i = 0; i < 2 * N; i++)
                    {
                        okenska[i] = (Math.Sin((Math.PI / (2 * N)) * (i + 0.5)));
                    }

                    //IMDTC
                    double[,] IMTDC = new double[st_okvirjev, 2*N];
                    for(int i=0; i<st_okvirjev; i++)
                    {
                        for(int n=0; n<2*N; n++)
                        {
                            double vsota = 0;
                            for(int k=0; k<N; k++)
                            {
                                vsota += MTDC[i, k] * Math.Cos(Math.PI / N * (n + 0.5 + N / 2.0) * (k + 0.5));
                            }
                            IMTDC[i, n] = (2.0 / N * vsota) * okenska[n];
                        }
                    }

                    int okvir_1 = 0;
                    int okvir_2 = 1;
                    int index_1 = N;
                    int index_2 = 0;
                    for(int i=0; i<channels[c].Length; i++)
                    {
                        channels[0][i] = (short)Math.Round(IMTDC[okvir_1,index_1] + IMTDC[okvir_2,index_2]);
                        index_1++;
                        index_2++;
                        if(index_1 == 2 * N)
                        {
                            index_1 = N;
                            index_2 = 0;
                            okvir_1++;
                            okvir_2++;
                        }
                    }
                }


                short[] d_left = new short[st_vzorcev / 2];
                short[] d_right = new short[st_vzorcev / 2];

                for(int i=0; i<st_vzorcev/2; i++)
                {
                    d_left[i] = (short)(d_mid[i] + d_side[i]);
                    d_right[i] = (short)(d_mid[i] - d_side[i]);
                }

                short[] d_buff = new short[st_vzorcev];

                int ind = 0;
                for (int i = 0; i < st_vzorcev; i+=2)
                {
                    d_buff[i] = d_left[ind];
                    d_buff[i + 1] = d_right[ind];
                    ind++;
                }

                byte[] d_byte_buff = new byte[st_vzorcev*2];
                Buffer.BlockCopy(d_buff, 0, d_byte_buff, 0, st_vzorcev * 2);

                using (WaveFileWriter w = new WaveFileWriter("out.wav", new WaveFormat(sample_rate, 2)))
                {
                    w.Write(d_byte_buff, 0, st_vzorcev*2);
                }

            }
        }
    }
}