///
// Created by Иван_Архипов on 24.11.2017.
//

#include "DdsSubfile.h"

#include "../BinaryData.h"
#include "../DatFile.h"
#include "../Common/DatException.h"

namespace LOTRO_DAT {
    DdsSubfile::DdsSubfile() {}

    DdsSubfile::DdsSubfile(DatFile *dat, long long fragments_count, long long unknown1,
                                      long long file_id, long long file_offset, long long file_size,
                                      long long timestamp,
                                      long long version, long long block_size)
            : Subfile(dat, fragments_count, unknown1, file_id, file_offset, file_size, timestamp, version, block_size) {
        BinaryData header(20);
        dat_->ReadData(header, 10, file_offset_ + 8);
        compressed_ = header.CheckCompression();
    }

    FILE_TYPE DdsSubfile::FileType() const {
        return DDS;
    }

    std::string DdsSubfile::Extension() const {
        return ".dds";
    }

    bool DdsSubfile::PrepareForExport(const BinaryData &file_data, long long &export_size, std::vector<BinaryData> &binary_data,
                                      std::vector<std::u16string> &text_data, std::vector<YAML::Node> &options) {
        BinaryData data = file_data;
        if (compressed_)
            data = data.DecompressData(4);

        BinaryData ddsData(data.size() - 24 + 128);
        for (int i = 0; i < 128; i++)
            ddsData[i] = 0;

        memcpy(ddsData.data() + 128, data.data() + 24, data.size() - 24);

        ddsData[0] = 0x44; // D
        ddsData[1] = 0x44; // D
        ddsData[2] = 0x53; // S
        ddsData[3] = 0x20;
        ddsData[4] = 0x7C;

        ddsData[8] = 7;
        ddsData[9] = 0x10;

        // width, height
        ddsData[12] = data[12];
        ddsData[13] = data[13];
        ddsData[14] = data[14];
        ddsData[15] = data[15];

        ddsData[16] = data[8];
        ddsData[17] = data[9];
        ddsData[18] = data[10];
        ddsData[19] = data[11];

        long long compression = data.ToNumber<4>(0x10);

        switch (compression) {
            case 20:        // 14 00 00 00 - 888 (R8G8B8)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x18;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                break;
            case 21:        // 15 00 00 00 - 8888 (R8G8B8A8)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x20;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                ddsData[0x6B] = 0xFF;
                break;
            case 28:        // 1C 00 00 00 - 332 (?)
                ddsData[0x4C] = 0x20;  // ?
                ddsData[0x50] = 0x40;  // compressed or not

                ddsData[0x58] = 0x08;  // bytes per pixel
                ddsData[0x5E] = 0xFF;
                ddsData[0x61] = 0xFF;
                ddsData[0x64] = 0xFF;
                break;
            case 827611204: // 44 58 54 31 - DXT1
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 49;
                break;
            case 861165636: // 44 58 54 33 - DXT3
                ddsData[22] = 1;
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 51;

                ddsData[108] = 8;
                ddsData[109] = 16;
                ddsData[110] = 64;
                break;
            case 894720068: // 44 58 54 35 - DXT5
                ddsData[10] = 8;
                ddsData[22] = 1;
                ddsData[28] = 1;
                ddsData[76] = 32;
                ddsData[80] = 4;

                ddsData[84] = 68;
                ddsData[85] = 88;
                ddsData[86] = 84;
                ddsData[87] = 53;

                ddsData[88] = 32;
                ddsData[94] = 255;
                ddsData[97] = 255;
                ddsData[100] = 255;
                ddsData[107] = 255;
                ddsData[109] = 16;
                break;
            default:
                throw DatException("Bad DdsSubfile::PrepareAsBinary() - unknown header format.", EXPORT_EXCEPTION);
        }

        export_size = 1;
        binary_data.emplace_back(ddsData);
        text_data.emplace_back(u"");
        options.emplace_back(YAML::Node());

        options[0]["file_id"] = file_id();
        options[0]["extension"] = Extension();
        return true;
    }

    BinaryData DdsSubfile::MakeForImport(const BinaryData &old_data, const BinaryData &binary_data, const std::u16string &text_data,
                              const YAML::Node &options) {
        if (!options["extension"] || options["extension"].as<std::string>() != Extension() ||
            !options["file_id"] || options["file_id"].as<long long>() != file_id()) {
            throw DatException("Bad DdsSubfile::MakeForImport() - invalid options data!", IMPORT_EXCEPTION);
        }
        if (compressed_)
            return old_data.CutData(0, 12) + (old_data.CutData(12, 16) + binary_data.CutData(128)).CompressData();
        else
            return old_data.CutData(0, 16) + binary_data.CutData(128);
    }
};