#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>
class Audio
{
private:
    struct RiffHeader
    {
        char chunkId[4];
        int32_t chunkSize;
        char format[4];
    };
    struct FirstSubchunk
    {
        char id[4];
        int32_t size;
        int16_t format,
            channelsNumber;
        int32_t sampleRate,
            byteRate;
        int16_t blockAlign,
            bitsPerSample;
    };
    struct SecondSubchunk
    {
        char id[4];
        int32_t size;
        int16_t *data;
    };

    std::string fileName;
    FILE *audioFile;
    RiffHeader riffHeader;
    FirstSubchunk firstSubchunk;
    SecondSubchunk secondSubchunk;

public:
    Audio(char *fileName)
    {
        this->fileName = fileName;
        audioFile = fopen(fileName, "rb");
        if (!audioFile)
        {
            std::cout << "File error..." << std::endl;
        }
        else
        {
            std::fread(&riffHeader, sizeof(riffHeader), 1, audioFile);
            std::fread(&firstSubchunk, sizeof(firstSubchunk), 1, audioFile);
            std::fread(&secondSubchunk, sizeof(secondSubchunk), 1, audioFile);
            int samplesNumber = secondSubchunk.size / firstSubchunk.blockAlign;
            secondSubchunk.data = (int16_t *)(realloc(secondSubchunk.data, samplesNumber));
            for (size_t i = 0; i < samplesNumber; i++)
            {
                std::fread(&secondSubchunk.data[i], firstSubchunk.blockAlign, 1, audioFile);
            }
        }
        std::fclose(audioFile);
    }

    void info()
    {
        std::cout << "Riff header: " << std::endl;
        std::cout << "Chunk id: " << riffHeader.chunkId << std::endl;
        std::cout << "Chunk size: " << riffHeader.chunkSize << std::endl;
        std::cout << "Format: " << riffHeader.format << std::endl;
        std::cout << std::endl;

        std::cout << "First subchunk: " << std::endl;
        std::cout << "Id: " << firstSubchunk.id << std::endl;
        std::cout << "Size: " << firstSubchunk.size << std::endl;
        std::cout << "Format: " << firstSubchunk.format << std::endl;
        std::cout << "Channels number: " << firstSubchunk.channelsNumber << std::endl;
        std::cout << "Sample rate: " << firstSubchunk.sampleRate << std::endl;
        std::cout << "Byte rate: " << firstSubchunk.byteRate << std::endl;
        std::cout << "Block align: " << firstSubchunk.blockAlign << std::endl;
        std::cout << "Bits per sample: " << firstSubchunk.bitsPerSample << std::endl;
        std::cout << std::endl;

        std::cout << "Second subchunk: " << std::endl;
        std::cout << "Id: " << secondSubchunk.id << std::endl;
        std::cout << "Size: " << secondSubchunk.size << std::endl;
        int answer;
        std::cout
            << "Print data? (1 - yes, 2 - no)" << std::endl;
        std::cin >> answer;
        if (answer == 1)
        {
            std::cout << "Data: " << std::endl;
            for (size_t i = 0; i < secondSubchunk.size / firstSubchunk.blockAlign; i++)
            {
                std::cout << std::setw(8) << secondSubchunk.data[i];
            }
        }
    }

    void resize(int k)
    {
        int sampleNumber = secondSubchunk.size / firstSubchunk.blockAlign;
        int16_t newData[sampleNumber * k];
        for (size_t i = 0; i < sampleNumber; i++)
        {
            for (size_t j = 0; j < k; j++)
            {
                newData[k * i + j] = secondSubchunk.data[i];
            }
        }
        secondSubchunk.size *= k;
        riffHeader.chunkSize = 36 + secondSubchunk.size;
        delete[] secondSubchunk.data;
        secondSubchunk.data = newData;
    }

    void save(char *fileName)
    {
        std::ofstream create(fileName, std::ios::binary);
        create.close();
        FILE *output = fopen(fileName, "w");
        std::fwrite(&riffHeader, sizeof(riffHeader), 1, output);
        std::fwrite(&firstSubchunk, sizeof(firstSubchunk), 1, output);
        std::fwrite(&secondSubchunk, sizeof(secondSubchunk), 1, output);
        for (size_t i = 0; i < secondSubchunk.size / firstSubchunk.blockAlign; i++)
        {
            std::fwrite(&secondSubchunk.data[i], firstSubchunk.blockAlign, 1, output);
        }
        std::fclose(output);
    }
};

int main()
{
    char *inputFileName,
        *outputFileName;
    std::string line;

    std::cout << "Enter input file name: " << std::endl;
    std::getline(std::cin, line);
    std::cout << std::endl;

    inputFileName = line.data();
    Audio audio(inputFileName);
    audio.info();
    std::cout << std::endl;

    int fileScale = 2;
    std::cout << "Enter file scale: " << std::endl;
    std::cin >> fileScale;
    audio.resize(fileScale);
    std::cout << std::endl;

    line.clear();
    std::cout << "Enter output file name: " << std::endl;
    std::getline(std::cin, line);

    outputFileName = line.data();
    audio.save(outputFileName);
}