#include <fstream>
#include <string>
#include <iostream>
#include <vector>
#include <cstring>
#include <sstream>

struct WaveHeader
{
    char ChunkID_ [4];
    int ChunkDataSize_;
    char Format_ [4];
    char SubChunk1ID_ [4];
    int SubChunk1Size_;
    short int AudioFormat_;
    short int NumChannels_;
    int SampleRate_;
    int ByteRate_;
    short int BlockAlign_;
    short int BitsPerSample_;
    char SubChank2ID_ [4];
    int SubChank2Size_;
};

bool headers_are_same_type(const WaveHeader& header1, const WaveHeader& header2)
{
    return memcmp(&header1, &header2, sizeof(WaveHeader) - sizeof(int)) == 0;
}

void load_wav_headers(const std::vector<std::string>& file_names, std::vector<WaveHeader>* wave_headers)
{
    if (wave_headers && file_names.size() > 0)
    {
        wave_headers->clear();
        for (auto file_name : file_names)
        {
            std::ifstream input_file;
            int length = 0;

            input_file.open(file_name, std::fstream::binary);
            input_file.seekg (0, std::ios::end);
            length = input_file.tellg();
            if (length > sizeof(WaveHeader))
            {
                WaveHeader header;

                input_file.seekg (0, std::ios::beg);
                input_file.read(reinterpret_cast<char*>(&header), sizeof(WaveHeader));
                wave_headers->push_back(header);
            }
            input_file.close();
        }
    }
}

bool headers_are_same_type(const std::vector<std::string>& file_names, std::vector<WaveHeader>* wave_headers)
{
    if (wave_headers && file_names.size() > 0)
    {
        load_wav_headers(file_names, wave_headers);
        if (wave_headers->size() == 1) return true;
        for (auto current_wave_header = wave_headers->begin() + 1; current_wave_header != wave_headers->end(); ++current_wave_header)
            if (!headers_are_same_type(*(wave_headers->begin()), *current_wave_header)) return false;
        return true;
    }
    return false;
}

void fill_file_names(std::vector<std::string>* file_names)
{
    if (file_names)
    {
        file_names->clear();
        for (int i = 0; i < 36; ++i)
        {
            std::ostringstream file_name;

            file_name << "c:\\!!!test\\" << (i + 1) << ".wav";
            file_names->push_back(file_name.str());
        }
    }
}

int calculate_length(const std::vector<WaveHeader>& wave_headers)
{
    int length = 0;

    for (auto wave_header : wave_headers)
        length += wave_header.SubChank2Size_;
    return length;
}

int main(int argc, char *argv[])
{
    std::vector<std::string> file_names;
    std::vector<WaveHeader> wave_headers;

    fill_file_names(&file_names);
    if (headers_are_same_type(file_names, &wave_headers))
    {
        std::cout << "All wav headers are same" << std::endl;

        int total_length = calculate_length(wave_headers);
        std::cout << "Total length = " << total_length << "B" << std::endl;

        WaveHeader result_header = wave_headers[0];
        result_header.SubChank2Size_ = total_length;

        std::ofstream output_file;
        output_file.open("c:\\!!!test\\result.wav", std::fstream::binary);

        output_file.write(reinterpret_cast<char*>(&result_header), sizeof(WaveHeader));

        for (size_t current_file_index = 0; current_file_index < file_names.size(); ++current_file_index)
        {
            char *input_buffer = new char[wave_headers[current_file_index].SubChank2Size_];
            std::ifstream input_file;
            int read_length;

            input_file.open(file_names[current_file_index], std::fstream::binary);
            input_file.seekg(sizeof(WaveHeader), std::ios::beg);
            input_file.read(input_buffer, wave_headers[current_file_index].SubChank2Size_);
            read_length = input_file.gcount();
            std::cout << "\"" << file_names[current_file_index] << "\":" << wave_headers[current_file_index].SubChank2Size_ << ":" << read_length << std::endl;
            output_file.write(input_buffer, read_length);
            input_file.close();
            delete[] input_buffer;
        }
        output_file.close();
    }
    else
        std::cerr << "Where are different types of wav headers!" << std::endl;
    std::cin.get();
}