/**************************************************************************
 *
 * Copyright 2011-2012 VMware, 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 <assert.h>
#include <stdio.h>

#include <iostream>
#include <sstream>
#include <memory>

#include "state_writer.hpp"
#include "com_ptr.hpp"
#include "d3d8imports.hpp"
#include "d3dshader.hpp"
#include "d3dstate.hpp"


namespace d3dstate {


typedef HRESULT (STDMETHODCALLTYPE IDirect3DDevice8::*GetShaderFunctionMethod)(DWORD Handle, void* pData, DWORD* pSizeOfData);


struct VertexShaderGetter
{
    HRESULT GetShader(IDirect3DDevice8 *pDevice, DWORD *pHandle) {
        HRESULT hr = pDevice->GetVertexShader(pHandle);
        if (SUCCEEDED(hr) && (*pHandle & 1) == 0) {
            // Handle is a FVF code.
            *pHandle = 0;
        }
        return hr;
    }
    HRESULT GetShaderFunction(IDirect3DDevice8 *pDevice, DWORD Handle, void* pData, DWORD* pSizeOfData) {
        return pDevice->GetVertexShaderFunction(Handle, pData, pSizeOfData);
    }
};

struct PixelShaderGetter
{
    HRESULT GetShader(IDirect3DDevice8 *pDevice, DWORD *pHandle) {
        return pDevice->GetPixelShader(pHandle);
    }
    HRESULT GetShaderFunction(IDirect3DDevice8 *pDevice, DWORD Handle, void* pData, DWORD* pSizeOfData) {
        return pDevice->GetPixelShaderFunction(Handle, pData, pSizeOfData);
    }
};

template<class Getter>
inline void
dumpShader(StateWriter &writer, IDirect3DDevice8 *pDevice, const char *name) {
    Getter getter;
    HRESULT hr;

    DWORD dwShader = 0;
    hr = getter.GetShader(pDevice, &dwShader);
    if (FAILED(hr) || !dwShader) {
        return;
    }

    DWORD SizeOfData = 0;

    hr = getter.GetShaderFunction(pDevice, dwShader, NULL, &SizeOfData);
    if (SUCCEEDED(hr)) {
        assert(SizeOfData % sizeof(DWORD) == 0);
        std::unique_ptr<DWORD []> pData(new DWORD[SizeOfData / sizeof(DWORD)]);
        hr = getter.GetShaderFunction(pDevice, dwShader, pData.get(), &SizeOfData);
        if (SUCCEEDED(hr)) {
            com_ptr<IDisassemblyBuffer> pDisassembly;
            hr = DisassembleShader(pData.get(), &pDisassembly);
            if (SUCCEEDED(hr)) {
                writer.beginMember(name);
                writer.writeString((const char *)pDisassembly->GetBufferPointer() /*, pDisassembly->GetBufferSize() */);
                writer.endMember();
            }
        }
    }
}

static void
dumpShaders(StateWriter &writer, IDirect3DDevice8 *pDevice)
{
    writer.beginMember("shaders");
    writer.beginObject();

    dumpShader<VertexShaderGetter>(writer, pDevice, "vertex");
    dumpShader<PixelShaderGetter>(writer, pDevice, "pixel");

    writer.endObject();
    writer.endMember(); // shaders
}

static void
dumpTextureStates(StateWriter &writer, IDirect3DDevice8 *pDevice)
{
#define _DUMP_TS_INT(x) { \
    DWORD rsDword = 0; \
    pDevice->GetTextureStageState(i, x, &rsDword); \
    writer.writeIntMember(#x, rsDword); \
}

#define _DUMP_TS_FLOAT(x) { \
    float rsFloat = 0.0f; \
    pDevice->GetTextureStageState(i, x, (DWORD *)&rsFloat); \
    writer.writeFloatMember(#x, rsFloat); \
}

    for (int i = 0; i < 8; i++)
    {
        std::ostringstream oss;
        oss << "TextureStageState" << i;
        writer.beginMember(oss.str());
        writer.beginObject();

        _DUMP_TS_INT(D3DTSS_COLOROP);
        _DUMP_TS_INT(D3DTSS_COLORARG1);
        _DUMP_TS_INT(D3DTSS_COLORARG2);
        _DUMP_TS_INT(D3DTSS_ALPHAOP);
        _DUMP_TS_INT(D3DTSS_ALPHAARG1);
        _DUMP_TS_INT(D3DTSS_ALPHAARG2);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVMAT00);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVMAT01);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVMAT10);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVMAT11);
        _DUMP_TS_INT(D3DTSS_TEXCOORDINDEX);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVLSCALE);
        _DUMP_TS_FLOAT(D3DTSS_BUMPENVLOFFSET);
        _DUMP_TS_INT(D3DTSS_TEXTURETRANSFORMFLAGS);
        _DUMP_TS_INT(D3DTSS_COLORARG0);
        _DUMP_TS_INT(D3DTSS_ALPHAARG0);
        _DUMP_TS_INT(D3DTSS_RESULTARG);

        writer.endObject();
        writer.endMember();
    }

#undef _DUMP_TS_INT
#undef _DUMP_TS_FLOAT
}

static void
dumpViewport(StateWriter &writer, IDirect3DDevice8 *pDevice)
{
    writer.beginMember("Viewport");
    writer.beginObject();

    D3DVIEWPORT8 vp;
    pDevice->GetViewport(&vp);
    writer.writeIntMember("X", vp.X);
    writer.writeIntMember("Y", vp.Y);
    writer.writeIntMember("Width", vp.Width);
    writer.writeIntMember("Height", vp.Height);
    writer.writeFloatMember("MinZ", vp.MinZ);
    writer.writeFloatMember("MaxZ", vp.MaxZ);

    writer.endObject();
    writer.endMember();
}

static void
dumpRenderstate(StateWriter &writer, IDirect3DDevice8 *pDevice)
{
#define _DUMP_RS_INT(x) { \
    DWORD rsDword = 0; \
    pDevice->GetRenderState(x, &rsDword); \
    writer.writeIntMember(#x, rsDword); \
}

#define _DUMP_RS_FLOAT(x) { \
    float rsFloat = 0.0f; \
    pDevice->GetRenderState(x, (DWORD *)&rsFloat); \
    writer.writeFloatMember(#x, rsFloat); \
}

    writer.beginMember("parameters");
    writer.beginObject();

    _DUMP_RS_INT(D3DRS_ZENABLE);
    _DUMP_RS_INT(D3DRS_FILLMODE);
    _DUMP_RS_INT(D3DRS_SHADEMODE);
    _DUMP_RS_INT(D3DRS_ZWRITEENABLE);
    _DUMP_RS_INT(D3DRS_ALPHATESTENABLE);
    _DUMP_RS_INT(D3DRS_LASTPIXEL);
    _DUMP_RS_INT(D3DRS_SRCBLEND);
    _DUMP_RS_INT(D3DRS_DESTBLEND);
    _DUMP_RS_INT(D3DRS_CULLMODE);
    _DUMP_RS_INT(D3DRS_ZFUNC);
    _DUMP_RS_INT(D3DRS_ALPHAREF);
    _DUMP_RS_INT(D3DRS_ALPHAFUNC);
    _DUMP_RS_INT(D3DRS_DITHERENABLE);
    _DUMP_RS_INT(D3DRS_ALPHABLENDENABLE);
    _DUMP_RS_INT(D3DRS_FOGENABLE);
    _DUMP_RS_INT(D3DRS_SPECULARENABLE);
    _DUMP_RS_INT(D3DRS_FOGCOLOR);
    _DUMP_RS_INT(D3DRS_FOGTABLEMODE);
    _DUMP_RS_FLOAT(D3DRS_FOGSTART);
    _DUMP_RS_FLOAT(D3DRS_FOGEND);
    _DUMP_RS_FLOAT(D3DRS_FOGDENSITY);
    _DUMP_RS_INT(D3DRS_ZBIAS);
    _DUMP_RS_INT(D3DRS_RANGEFOGENABLE);
    _DUMP_RS_INT(D3DRS_STENCILENABLE);
    _DUMP_RS_INT(D3DRS_STENCILFAIL);
    _DUMP_RS_INT(D3DRS_STENCILZFAIL);
    _DUMP_RS_INT(D3DRS_STENCILPASS);
    _DUMP_RS_INT(D3DRS_STENCILFUNC);
    _DUMP_RS_INT(D3DRS_STENCILREF);
    _DUMP_RS_INT(D3DRS_STENCILMASK);
    _DUMP_RS_INT(D3DRS_STENCILWRITEMASK);
    _DUMP_RS_INT(D3DRS_TEXTUREFACTOR);
    _DUMP_RS_INT(D3DRS_WRAP0);
    _DUMP_RS_INT(D3DRS_WRAP1);
    _DUMP_RS_INT(D3DRS_WRAP2);
    _DUMP_RS_INT(D3DRS_WRAP3);
    _DUMP_RS_INT(D3DRS_WRAP4);
    _DUMP_RS_INT(D3DRS_WRAP5);
    _DUMP_RS_INT(D3DRS_WRAP6);
    _DUMP_RS_INT(D3DRS_WRAP7);
    _DUMP_RS_INT(D3DRS_CLIPPING);
    _DUMP_RS_INT(D3DRS_LIGHTING);
    _DUMP_RS_FLOAT(D3DRS_AMBIENT);
    _DUMP_RS_INT(D3DRS_FOGVERTEXMODE);
    _DUMP_RS_INT(D3DRS_COLORVERTEX);
    _DUMP_RS_INT(D3DRS_LOCALVIEWER);
    _DUMP_RS_INT(D3DRS_NORMALIZENORMALS);
    _DUMP_RS_INT(D3DRS_DIFFUSEMATERIALSOURCE);
    _DUMP_RS_INT(D3DRS_SPECULARMATERIALSOURCE);
    _DUMP_RS_INT(D3DRS_AMBIENTMATERIALSOURCE);
    _DUMP_RS_INT(D3DRS_EMISSIVEMATERIALSOURCE);
    _DUMP_RS_INT(D3DRS_VERTEXBLEND);
    _DUMP_RS_INT(D3DRS_CLIPPLANEENABLE);
    _DUMP_RS_FLOAT(D3DRS_POINTSIZE);
    _DUMP_RS_FLOAT(D3DRS_POINTSIZE_MIN);
    _DUMP_RS_INT(D3DRS_POINTSPRITEENABLE);
    _DUMP_RS_INT(D3DRS_POINTSCALEENABLE);
    _DUMP_RS_FLOAT(D3DRS_POINTSCALE_A);
    _DUMP_RS_FLOAT(D3DRS_POINTSCALE_B);
    _DUMP_RS_FLOAT(D3DRS_POINTSCALE_C);
    _DUMP_RS_INT(D3DRS_MULTISAMPLEANTIALIAS);
    _DUMP_RS_INT(D3DRS_MULTISAMPLEMASK);
    _DUMP_RS_INT(D3DRS_PATCHEDGESTYLE);
    _DUMP_RS_INT(D3DRS_DEBUGMONITORTOKEN);
    _DUMP_RS_FLOAT(D3DRS_POINTSIZE_MAX);
    _DUMP_RS_INT(D3DRS_INDEXEDVERTEXBLENDENABLE);
    _DUMP_RS_INT(D3DRS_COLORWRITEENABLE);
    _DUMP_RS_INT(D3DRS_TWEENFACTOR);
    _DUMP_RS_INT(D3DRS_BLENDOP);
    _DUMP_RS_INT(D3DRS_POSITIONORDER);
    _DUMP_RS_INT(D3DRS_NORMALORDER);

#undef _DUMP_RS_INT
#undef _DUMP_RS_FLOAT

    dumpViewport(writer, pDevice);

    dumpTextureStates(writer, pDevice);

    writer.endObject();
    writer.endMember();
}

void
dumpDevice(StateWriter &writer, IDirect3DDevice8 *pDevice)
{
    dumpRenderstate(writer, pDevice);

    dumpShaders(writer, pDevice);

    writer.beginMember("textures");
    writer.beginObject();
    writer.endObject();
    writer.endMember(); // textures

    dumpFramebuffer(writer, pDevice);
}


} /* namespace d3dstate */