#include <vector>
#include <fftw3.h>
#include <complex>
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/opencv.hpp>
#include <mpg123.h>
#include <filesystem>
#include <string>
#include <windows.h>
#include <algorithm>
#include <lame/lame.h>
#include <cstdint>
#include <soxr.h>
#include "global.h"
#include "dr_wav.h"
#include "util.h"
#include "dr_mp3.h"
#include "miniaudio.h"
#include "embed.h"

using namespace std;
using namespace cv;


const double PI = 3.1416;

vector<double> tto(vector<vector<double>> &I, int N) {
    // 获取二维数组的行数和列数
    int rows = I.size();
    int cols = I[0].size();

    // 创建一维数组 K 来存储结果
    vector<double> K;

    // 将二维数组 I 转换为一维数组 K
    for (int p = 0; p < N; ++p) {
        for (int q = 0; q < N; ++q) {
            K.push_back(I[p][q]);
        }
    }

    return K;
}

vector<int> int_tto(vector<vector<int>> &I, int N)
{
	int rows = I.size();
	int cols = I[0].size();

	vector<int> K;

	for (int p = 0; p < N; p++)
	{
		for (int q = 0; q < N; q++)
		{
			K.push_back(I[p][q]);
		}
	}

	return K;
}

vector<vector<double>> ott(const vector<double>& I, int N)
{
	vector<vector<double>> K;

	for (int p = 0; p < N; p++)
	{
		vector<double> temp_row;

		for (int q = 0; q < N; q++)
		{
			temp_row.push_back(I[p * N + q]);
		}

		K.push_back(temp_row);
		temp_row.clear();
	}

	return K;
}

vector<vector<int>> int_ott(const vector<int>& I, int N) {
    // 初始化结果矩阵 K
    vector<vector<int>> K(N, vector<int>(N, 0));
    // 进行矩阵赋值
    for (int p = 0; p < N; ++p) {
        for (int q = 0; q < N; ++q) {
            K[p][q] = I[p * N + q];
        }
    }
    // 返回结果矩阵 K
    return K;
}

// 1D FFT function
void fft1d(vector<complex<double>>& data, bool invert) {
    int n = data.size();
    if (n <= 1) return;

    vector<complex<double>> even(n / 2);
    vector<complex<double>> odd(n / 2);

    for (int i = 0; i < n / 2; i++) {
        even[i] = data[i * 2];
        odd[i] = data[i * 2 + 1];
    }

    fft1d(even, invert);
    fft1d(odd, invert);

    double angle = 2 * PI / n * (invert ? -1 : 1);
    complex<double> w(1), wn(cos(angle), sin(angle));

    for (int i = 0; i < n / 2; i++) {
        complex<double> t = w * odd[i];
        complex<double> u = even[i];
        data[i] = u + t;
        data[i + n / 2] = u - t;
        w *= wn;
    }

    if (invert) {
        for (auto& x : data) x /= n;
    }
}

void fft2(Mat& input, Mat& output, bool invert = false, bool normalize = false)
{
    int rows = input.rows;
    int cols = input.cols;

    // Perform 1D FFT on each row
    for (int i = 0; i < rows; i++) {
        vector<complex<double>> row(cols);
        for (int j = 0; j < cols; j++) {
            row[j] = complex<double>(input.at<double>(i, j), 0);
        }
        fft1d(row, invert);
        for (int j = 0; j < cols; j++) {
            output.at<Vec2d>(i, j) = Vec2d(row[j].real(), row[j].imag());
        }
    }

    // Perform 1D FFT on each column
    for (int j = 0; j < cols; j++) {
        vector<complex<double>> col(rows);
        for (int i = 0; i < rows; i++) {
            col[i] = complex<double>(output.at<Vec2d>(i, j)[0], output.at<Vec2d>(i, j)[1]);
        }
        fft1d(col, invert);
        for (int i = 0; i < rows; i++) {
            output.at<Vec2d>(i, j) = Vec2d(col[i].real(), col[i].imag());
        }
    }

    // Normalize the result if required
    //if (normalize && invert) {
    //    double scale = 1.0 / (rows * cols);
    //    for (int i = 0; i < rows; ++i) {
    //        for (int j = 0; j < cols; ++j) {
    //            Vec2d& value = output.at<Vec2d>(i, j);
    //            value[0] *= scale;
    //            value[1] *= scale;
    //        }
    //    }
    //}
}

void zhishujufenjie62(MatrixXd Gp, int M, int Nmax, vector<complex<double>>& A_nm, vector<vector<int>>& zmlist) {
    //int rows = Gp.size();
    int rows = static_cast<int>(sqrt(Gp.size()));
    int cols = rows;
    const int size = 2 * Nmax + 1;
    // Allocate FFTW complex arrays
    fftw_complex* in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * rows * cols);
    fftw_complex* out = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * rows * cols);
    // Copy input data to FFTW format
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            in[i * cols + j][0] = Gp(i, j); // Real part
            in[i * cols + j][1] = 0.0;      // Imaginary part
        }
    }
    // Create FFTW plan
    //fftw_plan p = fftw_plan_dft_2d(rows, cols, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
    fftw_plan plan1 = fftw_plan_dft_2d(rows, cols, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
    //fftw_plan col_plan = fftw_plan_dft_2d(cols, rows, out, in, FFTW_FORWARD, FFTW_ESTIMATE);
    // Execute FFT
    fftw_execute(plan1);
    //fftw_execute(col_plan);
    // Copy FFT result to output vector
    vector<vector<complex<double>>> Gp_fft(rows, vector<complex<double>>(cols, complex<double>(0, 0)));
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            //Gp_fft[i][j] = complex<double>(out[i * cols + j][0], in[i * cols + j][1]);
            Gp_fft[i][j] = complex<double>(out[i * cols + j][0], out[i * cols + j][1]);
        }
    }
    // Cleanup
    fftw_destroy_plan(plan1);
    //fftw_destroy_plan(col_plan);
    fftw_free(in);
    fftw_free(out);
    vector<vector<complex<double>>> Ekm(M, vector<complex<double>>(M, complex<double>(0, 0)));
    double normalization = M * M;
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            Ekm[i][j] = Gp_fft[i][j] / normalization;
        }
    }
    // 初始化 E
    vector<vector<complex<double>>> E(size, vector<complex<double>>(size, complex<double>(0, 0)));
    // 填充 E
    for (int i = 0; i < Nmax; i++) {
        for (int j = 0; j < Nmax; j++) {
            E[i][j] = Ekm[M - Nmax + i][M - Nmax + j];
        }
        for (int j = 0; j <= Nmax; j++) {
            E[i][Nmax + j] = Ekm[M - Nmax + i][j];
        }
    }
    for (int i = 0; i <= Nmax; i++) {
        for (int j = 0; j < Nmax; j++) {
            E[Nmax + i][j] = Ekm[i][M - Nmax + j];
        }
        for (int j = 0; j <= Nmax; j++) {
            E[Nmax + i][Nmax + j] = Ekm[i][j];
        }
    }
    int c = 0;
    for (int k = 0; k < size; k++) {
        for (int m = 0; m < size; m++) {
            zmlist[c][0] = k - Nmax;
            zmlist[c][1] = m - Nmax;
            A_nm[c] = E[k][m];
            c++;
        }
    }
}

vector<int16_t> floatToPCM16(vector<double>& input, float scaleFactor = 32767.0f) {
    vector<int16_t> output(input.size());
    for (int i = 0; i < input.size(); i++) {
        // 将浮点数转换为16位整数，注意避免溢出  
        int16_t value = static_cast<int16_t>(input[i] * scaleFactor);
        if (value > 32767) value = 32767;
        if (value < -32768) value = -32768;
        output[i] = value;
    }
    return output;
}

double getGlobalProgress()
{
    return g_audio_wm_progress;
}

void save_audio_drwav(const wchar_t* outputFilename, vector<double>& yo, int sampleRate, int channels)
{
    std::vector<int16_t> audioData(yo.size());
    for (size_t i = 0; i < yo.size(); ++i) {
        audioData[i] = static_cast<int16_t>(max(-1.0, min(1.0, yo[i])) * 32767);
    }

    drwav wav;
    const drwav_data_format drwav_data_format{
        drwav_container_riff,
        DR_WAVE_FORMAT_PCM,
        static_cast<uint16_t>(channels),
        static_cast<uint32_t>(sampleRate),
        16
    };

    // 调试输出路径
    std::wcout << L"Output path: " << outputFilename << std::endl;

    if (!drwav_init_file_write_w(&wav, outputFilename, &drwav_data_format, nullptr)) {
        std::cerr << "Failed to open WAV file for writing: " << outputFilename << std::endl;
        return;
    }

    drwav_write_pcm_frames(&wav, static_cast<drwav_uint64>(yo.size() / channels), audioData.data());
    drwav_uninit(&wav);
}

void save_audio_drmp3(const wchar_t* outputFilename, vector<double>& yo, int sampleRate, int channels)
{
    // outputFilename 是文件保存路径， yo 是double音频信号， sampleRate 是采样率， channels 是声道数， 用lame库保存mp3 文件
    // 创建LAME编码器
    lame_t lame = lame_init();
    lame_set_in_samplerate(lame, sampleRate);
    lame_set_num_channels(lame, channels);
    lame_set_out_samplerate(lame, sampleRate);
    //lame_set_brate(lame, bitrate);
    lame_set_quality(lame, 5); // 0-9, 5是中等质量
    lame_init_params(lame);

    // 打开输出文件
    FILE* mp3File = nullptr;
    errno_t err = _wfopen_s(&mp3File, outputFilename, L"wb");
    if (!mp3File) {
        std::cerr << "cann't open file: " << outputFilename << std::endl;
        lame_close(lame);
        return;
    }

    // Convert yo from double to short
    std::vector<short> pcmBuffer(yo.size());
    for (size_t i = 0; i < yo.size(); ++i) {
        pcmBuffer[i] = static_cast<short>(yo[i] * 32767.0); // Convert to 16-bit PCM
    }

    // Buffer for MP3 data
    const int MP3_BUFFER_SIZE = 1.25 * pcmBuffer.size() + 7200; // LAME recommendation
    std::vector<unsigned char> mp3Buffer(MP3_BUFFER_SIZE);

    // Encode PCM to MP3
    int mp3Bytes;
    if (channels == 1) {
        mp3Bytes = lame_encode_buffer(lame, pcmBuffer.data(), nullptr, pcmBuffer.size(), mp3Buffer.data(), MP3_BUFFER_SIZE);
    }
    else {
        mp3Bytes = lame_encode_buffer_interleaved(lame, pcmBuffer.data(), pcmBuffer.size() / channels, mp3Buffer.data(), MP3_BUFFER_SIZE);
    }

    if (mp3Bytes < 0) {
        std::cerr << "LAME encoding error: " << mp3Bytes << std::endl;
        fclose(mp3File);
        lame_close(lame);
        return;
    }

    // Write MP3 data to file
    fwrite(mp3Buffer.data(), 1, mp3Bytes, mp3File);

    // Flush LAME buffer
    mp3Bytes = lame_encode_flush(lame, mp3Buffer.data(), MP3_BUFFER_SIZE);
    fwrite(mp3Buffer.data(), 1, mp3Bytes, mp3File);

    // Clean up
    fclose(mp3File);
    lame_close(lame);
}

string Widen(const wchar_t* wstr) {
    if (!wstr) return {}; // 检查空指针

    // 获取所需的字符数
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, nullptr, 0, nullptr, nullptr);

    // 创建足够大的字符串
    std::string str(size_needed, '\0');
    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &str[0], size_needed, nullptr, nullptr);

    return str;
}

vector<double> mp3ToDoubleVector(const char* mp3File, int &channels, long &rate, int &wavelength)
{
    mpg123_init();
    mpg123_handle* mh = mpg123_new(NULL, NULL);
    if (mh == nullptr) {
        throw std::runtime_error("Failed to create mpg123 handle");
    }

    if (mpg123_open(mh, mp3File) != MPG123_OK) {
        mpg123_delete(mh);
        throw std::runtime_error("Failed to open MP3 file");
    }

    int encoding;

    mpg123_getformat(mh, &rate, &channels, &encoding);

    // 获取比特率
    //mpg123_frameinfo2 id3v2;
    //mpg123_info2(mh, &id3v2);
    //bitrate = id3v2.bitrate;
    std::vector<double> audioData;
    unsigned char buffer[4096];
    size_t done;

    while (mpg123_read(mh, buffer, sizeof(buffer), &done) == MPG123_OK) {
        size_t numSamples = done / sizeof(short);
        audioData.resize(audioData.size() + numSamples);

        // Convert to double and store in vector
        for (size_t i = 0; i < numSamples; ++i) {
            audioData[audioData.size() - numSamples + i] =
                static_cast<double>(reinterpret_cast<short*>(buffer)[i]) / SHRT_MAX;
        }
    }

    mpg123_close(mh);
    mpg123_delete(mh);
    mpg123_exit();

    wavelength = audioData.size() / channels;

    return audioData;
}

bool isMp3File(fs::path& path, string fpath) 
{
    // 检查文件是否存在
    if (!fs::exists(fpath)) {
        std::cerr << "File does not exist: " << std::endl;
        return false;
    }
    // 检查文件扩展名
    return path.extension() == ".mp3" || path.extension() == ".MP3";
}

string toUTF8(const std::wstring& wstr) {
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), static_cast<int>(wstr.size()), nullptr, 0, nullptr, nullptr);
    std::string str(size_needed, 0);
    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), static_cast<int>(wstr.size()), &str[0], size_needed, nullptr, nullptr);
    return str;
}

wstring toWideString(const string& str) {
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0);
    std::wstring wstr(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), &wstr[0], size_needed);
    return wstr;
}

void modifyAndCombinePath(const char* path, const char* save_path, char* output) {
    // 提取文件名
    const char* filename = strrchr(path, '/'); // 找到最后一个 '/'
    if (!filename) {
        filename = strrchr(path, '\\'); // 如果是 Windows 路径
    }

    if (filename) {
        filename++; // 跳过 '/'
    }
    else {
        filename = path; // 如果没有找到 '/', 使用整个路径
    }

    // 拼接新的文件名
    char newFileName[256]; // 假设文件名长度不会超过 255
    snprintf(newFileName, sizeof(newFileName), "%.*s_wm_release.wav",
        (int)(strrchr(filename, '.') - filename), filename);

    // 拼接保存路径和新文件名
    snprintf(output, 512, "%s%s", save_path, newFileName);
}

string ConvertUTF16ToMBCS(const wchar_t* utf16Str)
{
    // 获取转换后的字符串长度
    int sLen = WideCharToMultiByte(CP_ACP, 0, utf16Str, -1, NULL, 0, NULL, NULL);
    if (sLen == 0)
    {
        std::cerr << "Error converting UTF-16 to system encoding" << std::endl;
        return "";
    }

    std::string str(sLen, 0);
    WideCharToMultiByte(CP_ACP, 0, utf16Str, -1, &str[0], sLen, NULL, NULL);
    return str;
}

// 读取 WAV 文件
bool transResampleReadWAV(const char* inputPath, vector<float>& buffer, int& sampleRate, int& channels) {
    SF_INFO sfInfo;
    SNDFILE* infile = sf_open(inputPath, SFM_READ, &sfInfo);
    if (!infile) {
        std::cerr << "Error opening input file: " << sf_strerror(infile) << std::endl;
        return false;
    }
    channels = sfInfo.channels;
    sampleRate = sfInfo.samplerate;
    buffer.resize(sfInfo.frames * sfInfo.channels);
    sf_count_t readFrames = sf_readf_float(infile, buffer.data(), sfInfo.frames);
    sf_close(infile);

    // Resize buffer to the actual number of read frames
    buffer.resize(readFrames);

    return true;
}

// 写入 WAV 文件
bool transResampleWriteWAV(const char* outputPath, const vector<float>& buffer, double sampleRate, int channels) {
    SF_INFO sfInfo{};
    sfInfo.frames = buffer.size() / channels; // Assuming stereo (2 channels)
    sfInfo.samplerate = static_cast<int>(sampleRate);
    sfInfo.channels = channels; // Assuming stereo
    sfInfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;

    SNDFILE* outfile = sf_open(outputPath, SFM_WRITE, &sfInfo);
    if (!outfile) {
        cerr << "Error opening output file: " << sf_strerror(outfile) << endl;
        return false;
    }

    sf_count_t writtenFrames = sf_writef_float(outfile, buffer.data(), sfInfo.frames);
    sf_close(outfile);

    if (writtenFrames != sfInfo.frames) {
        cerr << "Error writing WAV file: " << outputPath << endl;
        return false;
    }

    return true;
}

// 重采样音频数据
void resample(const float* inputBuffer, size_t inputSize,
    float* outputBuffer, size_t& outputSize,
    double inputRate, double outputRate, int channels) {
    soxr_error_t error;

    // 创建重采样上下文
    soxr_t soxr = soxr_create(inputRate, outputRate, channels, &error, nullptr, nullptr, nullptr);
    if (error) {
        std::cerr << "Error creating soxr: " << error << std::endl;
        return;
    }

    // 进行重采样
    size_t outputFrames = outputSize;
    error = soxr_process(soxr, inputBuffer, inputSize, nullptr,
        outputBuffer, outputFrames, &outputSize);

    if (error) {
        cerr << "Error during resampling: " << error << endl;
    }

    // 清理
    soxr_delete(soxr);
}

void convert_wav(vector<double>& inputBuffer, int& inputRate, int channels, const wchar_t* outputPath) {
    cout << "Input buffer size: " << inputBuffer.size() << std::endl;
    double outputRate = 44100; // 目标采样率
    size_t inputSize = inputBuffer.size();
    size_t outputSize = static_cast<size_t>(static_cast<double>(inputSize) * outputRate / inputRate) + 1;
    vector<float> outputBuffer(outputSize);

    vector<float> in;
    for (auto i : inputBuffer) {
        in.push_back((float)i);
    }
    //// 调用重采样函数
    resample(in.data(), inputSize, outputBuffer.data(), outputSize, inputRate, outputRate, channels);

    // 写入输出 WAV 文件
    vector<double> out;
    for (auto i : outputBuffer) {
        out.push_back((double)i);
    }
    inputBuffer = out;
    inputRate = outputRate;
    //save_audio_drwav(outputPath, out, outputRate, channels);
    return;
}

wstring AddSuffixToPath(const wchar_t* originalPath, const wstring& suffix) {
    wstring path(originalPath);

    // 查找最后一个点的位置
    size_t dotPosition = path.find_last_of(L".");

    // 如果找到了点，插入 suffix
    if (dotPosition != wstring::npos) {
        path.insert(dotPosition, suffix);
    }
    else {
        // 如果没有找到点，直接在末尾添加 suffix
        path.append(suffix);
    }

    return path;
}

wstring string_to_wstring(const std::string& str) {
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), NULL, 0);
    std::wstring wstr(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), &wstr[0], size_needed);
    return wstr;
}

bool allEqual(const vector<double>& vec1, const vector<double>& vec2) {
    if (vec1.size() != vec2.size())
        return false;
    for (size_t i = 0; i < vec1.size(); i++) {
        if (vec1[i] != vec2[i])
            return false;
    }
    return true;
}