//=====================================================================
// Copyright 2008 (c), ATI Technologies Inc. All rights reserved.
// Copyright 2016 (c), Advanced Micro Devices, Inc. All rights reserved.
//=====================================================================
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

#include <stdio.h>
#include <stdlib.h>

#include "common.h"
#include "compressonator.h"
#include "tc_pluginapi.h"
#include "tc_plugininternal.h"

#ifdef _WIN32
#include "ddraw.h"
#include "d3d9types.h"
#pragma warning(disable : 4996)  //'fopen': This function or variable may be unsafe.
#endif

#include "dds.h"
#include "dds_file.h"
#include "dds_dx10.h"
#include "dds_helpers.h"

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif

CMIPS*      DDS_CMips = NULL;
const char* g_pszFilename;

#ifdef BUILD_AS_PLUGIN_DLL
DECLARE_PLUGIN(Plugin_DDS)
SET_PLUGIN_TYPE("IMAGE")
SET_PLUGIN_NAME("DDS")
#else
void* make_Plugin_DDS()
{
    return new Plugin_DDS;
}
#endif

Plugin_DDS::Plugin_DDS()
{
#ifdef _WIN32
    HRESULT hr;
    // Initialize COM (needed for WIC)
    if (FAILED(hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED)))
    {
        if (DDS_CMips)
            DDS_CMips->PrintError("Failed to initialize COM (%08X)\n", hr);
    }
#endif
}

Plugin_DDS::~Plugin_DDS()
{
}

int Plugin_DDS::TC_PluginSetSharedIO(void* Shared)
{
    if (Shared)
    {
        DDS_CMips = static_cast<CMIPS*>(Shared);
        return 0;
    }
    return 1;
}

int Plugin_DDS::TC_PluginGetVersion(TC_PluginVersion* pPluginVersion)
{
#ifdef _WIN32
    pPluginVersion->guid = g_GUID;
#endif
    pPluginVersion->dwAPIVersionMajor    = TC_API_VERSION_MAJOR;
    pPluginVersion->dwAPIVersionMinor    = TC_API_VERSION_MINOR;
    pPluginVersion->dwPluginVersionMajor = TC_PLUGIN_VERSION_MAJOR;
    pPluginVersion->dwPluginVersionMinor = TC_PLUGIN_VERSION_MINOR;
    return 0;
}

// No longer supported
int Plugin_DDS::TC_PluginFileLoadTexture(const char* pszFilename, CMP_Texture* srcTexture)
{
    (pszFilename);
    (srcTexture);
    return 0;
}

// No longer supported
int Plugin_DDS::TC_PluginFileSaveTexture(const char* pszFilename, CMP_Texture* srcTexture)
{
    (pszFilename);
    (srcTexture);
#ifdef _WIN32
    HRESULT hr = S_OK;
    return hr == S_OK ? 0 : -1;  // np: need to fix this : make all pligins return long type!
#else
    return 0;
#endif
}

int Plugin_DDS::TC_PluginFileLoadTexture(const char* pszFilename, MipSet* pMipSet)
{
    g_pszFilename = pszFilename;
    FILE* pFile   = NULL;
    pFile         = fopen(pszFilename, ("rb"));
    if (pFile == NULL)
    {
        DDS_CMips->PrintError("Error [%x]: DDS Plugin Failed to load texture file %s\n", IDS_ERROR_FILE_OPEN, pszFilename);
        return PE_Unknown;
    }

    CMP_DWORD dwFileHeader;
    fread(&dwFileHeader, sizeof(CMP_DWORD), 1, pFile);
    if (dwFileHeader != DDS_HEADER)
    {
        fclose(pFile);
        DDS_CMips->PrintError("Error [%x]: DDS Plugin Failed to load texture file %s\n", IDS_ERROR_NOT_DDS, pszFilename);
        return PE_Unknown;
    }

    DDSD2 ddsd;
    if (fread(&ddsd, sizeof(DDSD2), 1, pFile) != 1)
    {
        fclose(pFile);
        DDS_CMips->PrintError("Error [%x]: DDS Plugin Failed to load texture file %s\n", IDS_ERROR_NOT_DDS, pszFilename);
        return PE_Unknown;
    }

    if (!(ddsd.dwFlags & DDSD_MIPMAPCOUNT))
        ddsd.dwMipMapCount = 1;
    else if (ddsd.dwMipMapCount == 0)
    {
        fclose(pFile);
        DDS_CMips->PrintError("Error [%x]: DDS Plugin Failed to load texture file %s\n", IDS_ERROR_NOT_DDS, pszFilename);
        return PE_Unknown;
    }

    // if ((DDSHeader->ddspf.flags & DDS_FOURCC) && (MAKEFOURCC('D', 'X', '1', '0') == DDSHeader->ddspf.fourCC))
    if (ddsd.ddpfPixelFormat.dwFourCC == CMP_MAKEFOURCC('D', 'X', '1', '0'))
        return LoadDDS_DX10(pFile, &ddsd, pMipSet);

    // Prep for next revision
    // DDS_FILE_HEADER* DDSHeader = reinterpret_cast<DDS_FILE_HEADER*>(&ddsd);
    // Prechecks to set into mipset
    // if (DDSHeader->flags & DDS_HEADER_FLAGS_VOLUME) {
    //     // fill in volume mipset props
    // }
    // else if (DDSHeader->caps2 & DDS_CUBEMAP)
    // {
    //     // fill in cubemap mipset props
    // }


    // Prep for next revision
    DDS_FILE_HEADER* DDSHeader = reinterpret_cast<DDS_FILE_HEADER*>(&ddsd);
    DDS_PIXELFORMAT  DDSPF_L16 = {sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0};
    if ((DDSHeader->ddspf.flags & DDPF_LUMINANCE) && (DDSHeader->ddspf.RGBBitCount == 16) && (DDSHeader->ddspf.RBitMask & 0xffff) &&
        (DDSHeader->ddspf.GBitMask == 0) && (DDSHeader->ddspf.BBitMask == 0))
    {
        return LoadDDS_R16(pFile, &ddsd, pMipSet);
    }

    if ((DDSHeader->ddspf.flags & DDS_BUMPDUDV) && 
        (DDSHeader->ddspf.RGBBitCount == 32))
    {
        pMipSet->m_format = CMP_FORMAT_RGBA_8888_S;
        return LoadDDS_RGB8888_S(pFile, &ddsd, pMipSet, (ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) ? true : false);
    }


    // Try known FourCC first for legcay support
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_A32B32G32R32F)
        return LoadDDS_ABGR32F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_A16B16G16R16F)
        return LoadDDS_ABGR16F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_G32R32F)
        return LoadDDS_GR32F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_R32F)
        return LoadDDS_R32F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_R16F)
        return LoadDDS_R16F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_G16R16F)
        return LoadDDS_G16R16F(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_A16B16G16R16)
        return LoadDDS_ABGR16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_Q16W16V16U16)
        return LoadDDS_ABGR16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_G16R16)
        return LoadDDS_G16R16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC == D3DFMT_L16)
        return LoadDDS_R16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwFourCC)
        return LoadDDS_FourCC(pFile, &ddsd, pMipSet);

    if (ddsd.ddpfPixelFormat.dwLuminanceBitCount == 8 && (ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE))
        return LoadDDS_G8(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwLuminanceBitCount == 16 && (ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE) &&
             (ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS))
        return LoadDDS_AG8(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwLuminanceBitCount == 16 && (ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE) && (ddsd.ddpfPixelFormat.dwGBitMask == 0xffff))
        return LoadDDS_G16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwAlphaBitDepth == 8 && (ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHA))
        return LoadDDS_A8(pFile, &ddsd, pMipSet);
    if ((ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB) && !(ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) && (ddsd.ddpfPixelFormat.dwRGBBitCount == 16))
        return LoadDDS_RGB565(pFile, &ddsd, pMipSet);
    if ((ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB) && !(ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) && (ddsd.ddpfPixelFormat.dwRGBBitCount == 24))
        return LoadDDS_RGB888(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwRGBBitCount == 32 && (ddsd.ddpfPixelFormat.dwRBitMask == 0x3ff || ddsd.ddpfPixelFormat.dwRBitMask == 0x3ff00000))
        return LoadDDS_ARGB2101010(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwRGBBitCount == 32 && ddsd.ddpfPixelFormat.dwRBitMask == 0xffff && ddsd.ddpfPixelFormat.dwGBitMask == 0xffff0000)
        return LoadDDS_G16R16(pFile, &ddsd, pMipSet);
    if (ddsd.ddpfPixelFormat.dwLuminanceBitCount == 16 && (ddsd.ddpfPixelFormat.dwFlags & DDPF_LUMINANCE) && (ddsd.ddpfPixelFormat.dwRBitMask == 0xffff))
    {  // 16bpp Gray
        pMipSet->m_format = CMP_FORMAT_ABGR_16;
        return LoadDDS_ABGR16(pFile, &ddsd, pMipSet);
    }
    if (ddsd.ddpfPixelFormat.dwRGBBitCount == 16 && ddsd.ddpfPixelFormat.dwRBitMask == 0xffff)
    {
        pMipSet->m_format = CMP_FORMAT_R_16;
        return LoadDDS_R16(pFile, &ddsd, pMipSet);
    }
    if (ddsd.ddpfPixelFormat.dwRGBBitCount == 32)
    {
        pMipSet->m_format = CMP_FORMAT_ARGB_8888;
        return LoadDDS_RGB8888(pFile, &ddsd, pMipSet, (ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) ? true : false);
    }

    fclose(pFile);

    DDS_CMips->PrintError("Error [%x]: DDS Plugin Failed to load texture file %s\n", IDS_ERROR_UNSUPPORTED_TYPE, pszFilename);
    return PE_Unknown;
}

int Plugin_DDS::TC_PluginFileSaveTexture(const char* pszFilename, MipSet* pMipSet)
{
    assert(pszFilename);
    assert(pMipSet);

    FILE* pFile = NULL;
    pFile       = fopen(pszFilename, ("wb"));
    if (pFile == NULL)
    {
        return PE_Unknown;
    }

    fwrite(&DDS_HEADER, sizeof(CMP_DWORD), 1, pFile);

    if (pMipSet->m_dwFourCC == CMP_FOURCC_G8)
        return SaveDDS_G8(pFile, pMipSet);
    else if (pMipSet->m_dwFourCC == CMP_FOURCC_A8)
        return SaveDDS_A8(pFile, pMipSet);
    else if (IsD3D10Format(pMipSet))
        return SaveDDS_DX10(pFile, pMipSet);
    else if (pMipSet->m_dwFourCC)
        return SaveDDS_FourCC(pFile, pMipSet);
    else if (pMipSet->m_ChannelFormat == CF_Float16)
    {
        if (pMipSet->m_TextureDataType == TDT_R)
            return SaveDDS_R16F(pFile, pMipSet);
        else if (pMipSet->m_TextureDataType == TDT_RG)
            return SaveDDS_RG16F(pFile, pMipSet);
        else
            return SaveDDS_ABGR16F(pFile, pMipSet);
    }
    else if (pMipSet->m_ChannelFormat == CF_Float32)
    {
        if (pMipSet->m_TextureDataType == TDT_R)
            return SaveDDS_R32F(pFile, pMipSet);
        else if (pMipSet->m_TextureDataType == TDT_RG)
            return SaveDDS_RG32F(pFile, pMipSet);
        else
            return SaveDDS_ABGR32F(pFile, pMipSet);
    }
    else if (pMipSet->m_ChannelFormat == CF_2101010)
        return SaveDDS_ARGB2101010(pFile, pMipSet);
    else if (pMipSet->m_ChannelFormat == CF_16bit)
    {
        if (pMipSet->m_TextureDataType == TDT_R)
            return SaveDDS_R16(pFile, pMipSet);
        else if (pMipSet->m_TextureDataType == TDT_RG)
            return SaveDDS_RG16(pFile, pMipSet);
        else
            return SaveDDS_ABGR16(pFile, pMipSet);
    }
    else if (pMipSet->m_TextureDataType == TDT_RGB)
    {
        return SaveDDS_RGB888(pFile, pMipSet);
    }
    
    if (pMipSet->m_format == CMP_FORMAT_RGBA_8888_S)
        return SaveDDS_RGBA8888_S(pFile, pMipSet);

    return SaveDDS_ARGB8888(pFile, pMipSet);
}