/*
 * sp/engine/context.cpp
 */


#include <SP/engine/workspace.hpp>
#include <SP/engine/context.hpp>
#include <SP/interface/context.hpp>


//#include <SP/engine/project.hpp>
//#include <choreo/load.hpp>

#include <p3d/context.hpp>
#include <p3d/utility.hpp>
#include <p3d/view.hpp>
#include <p3d/directionallight.hpp>
#include <p3d/pointcamera.hpp>
#include <p3d/geometry.hpp>
#include <p3d/anim/drawablepose.hpp>
#include <radload/radload.hpp>

#include <radtime.hpp>
#include <radplatform.hpp>

#include <shlwapi.h>

#include <typeinfo>


#ifdef RAD_DEBUG
static const char* pddiDLL = "pddidx8d.dll";
#endif

#ifdef RAD_TUNE
static const char* pddiDLL = "pddidx8t.dll";
#endif

#ifdef RAD_RELEASE
static const char* pddiDLL = "pddidx8r.dll";
#endif


// global SPContext reference
SPContext* g_SPContext = 0;

extern Workspace* g_Workspace;


//---------------------------------------------------------------------------
// class SPContext - implementation
//---------------------------------------------------------------------------

SPContext::SPContext(HWND hwnd):
    m_HWnd(hwnd),

    m_Context(0),
    m_View(0),
    m_Camera(0),
    m_Light(0),
    m_Shader(0),

    m_CurrentTime(-1.0f),
    m_FPSIndex(0),
    m_SimRate(1.0f),

    m_MouseCapture(0),
    m_MouseX(0),
    m_MouseY(0),

    m_IsCameraLocked(false)
{
    memset(m_FPS, 0, sizeof(m_FPS));
}

SPContext::~SPContext()
{
    tRefCounted::Release(m_Shader);
    tRefCounted::Release(m_Light);
    tRefCounted::Release(m_Camera);
    tRefCounted::Release(m_View);
}

bool SPContext::Open()
{
    // p3d context init
    RECT wndRect;
    GetWindowRect(m_HWnd, &wndRect);

    tContextInitData init;
    init.hwnd = m_HWnd;
    init.displayMode = PDDI_DISPLAY_WINDOW;
    init.bufferMask = PDDI_BUFFER_COLOUR | PDDI_BUFFER_DEPTH;
    int wndWidth = wndRect.right - wndRect.left;
    int wndHeight = wndRect.bottom - wndRect.top;
    init.xsize = wndWidth;
    init.ysize = wndHeight;
    init.bpp = 32;
    strcpy(init.PDDIlib, pddiDLL);

    //p3d::platform->SetActiveContext(0);
    m_Context = p3d::platform->CreateContext(&init);
    if (m_Context == 0)
        return false;

    p3d::platform->SetActiveContext(m_Context);

    // Call into PDDI to enable Z-buffering.
    p3d::pddi->EnableZBuffer(true);


    radLoadInitialize();

    // This call installs chunk handlers for all the primary chunk types that
    // Pure3D supports.  This includes textures, materials, geometries, and the
    // like.  
    p3d::InstallDefaultLoaders();

    // install default choreo loaders
    //choreo::InstallDefaultLoaders();

    // p3d view init
    m_View = new tView;
    m_View->AddRef();

    m_View->SetBackgroundColour(tColour(64, 64, 128));
    m_View->SetAmbientLight(tColour(40, 40, 40));

    // p3d light init
    m_Light = new tDirectionalLight;
    m_Light->AddRef();

    m_Light->SetDirection(0.0f, 0.0f, 1.0f);
    m_Light->SetColour(tColour(255, 255, 255));
    m_View->AddLight(m_Light);

    // p3d camera init
    m_Camera = new tPointCamera;
    m_Camera->AddRef();
    m_Camera->SetNearPlane(0.01f);
    m_Camera->SetFarPlane(5000.0f);
    m_Camera->SetFOV(rmt::DegToRadian(90.0f), (float)wndWidth / (float)wndHeight);
    m_View->SetCamera(m_Camera);

    m_CameraTarget.Clear();
    m_CameraRotateX = rmt::DegToRadian(-45.0f);
    m_CameraRotateY = 0.0f;
    m_CameraDistance = 5.0f;

    // pddi shader
    m_Shader = p3d::device->NewShader("simple");
    m_Shader->AddRef();
    m_Shader->SetInt(PDDI_SP_ISLIT, 0);

    // workspace create
    if (g_Workspace == 0)
    {
        g_Workspace = new Workspace;
        g_Workspace->AddRef();
    }

    return true;
}

bool SPContext::Close()
{
    // p3d release stuff
    tRefCounted::Release(m_Shader);
    tRefCounted::Release(m_Light);
    tRefCounted::Release(m_Camera);
    tRefCounted::Release(m_View);

    // p3d context destroy
    if (m_Context != 0)
    {
        p3d::platform->DestroyContext(m_Context);
        m_Context = 0;
    }

    radLoadTerminate();

    return true;
}

bool SPContext::ViewResize(int w, int h)
{
    if (w <= 0)
        w = 1;
    if (h <= 0)
        h = 1;

    RECT wndRect;
    GetWindowRect(m_HWnd, &wndRect);
    int wndWidth = wndRect.right - wndRect.left;
    if (wndWidth <= 0)
        wndWidth = 1;
    int wndHeight = wndRect.bottom - wndRect.top;
    if (wndHeight <= 0)
        wndHeight = 1;

    if (w > wndWidth)
        w = wndWidth;
    if (h > wndHeight)
        h = wndHeight;

    m_View->SetWindow(0.0f, 0.0f, (float)w / (float)wndWidth, (float)h / (float)wndHeight);
    m_Camera->SetFOV(rmt::DegToRadian(90.0f), (float)w / (float)h);

    return true;
}

bool SPContext::Advance()
{
    // do time
    float deltaTime;
    {
        float newTime = (float)radTimeGetMilliseconds() / 1000.0f;

        if (m_CurrentTime < 0.0f)
        {
            deltaTime = 0.0f;
            m_CurrentTime = newTime;
        }
        else
        {
            deltaTime = newTime - m_CurrentTime;

            if (deltaTime < 0.0f)
            {
                deltaTime = 0.0f;
            }
            else
            {
                m_CurrentTime = newTime;
            }

            // for debugging
            if (deltaTime > 1.0f)
            {
                deltaTime = 1.0f / 60.0f;
            }
            else
            {
                // do fps
                m_FPS[m_FPSIndex] = deltaTime;
                m_FPSIndex = (m_FPSIndex + 1) % MAX_FPS_COUNT;
            }
        }
    }

    float simDeltaTime = m_SimRate * deltaTime;
	if ( g_Workspace )
	{
		g_Workspace->Advance(simDeltaTime * 1000.0f);
	}

    // update camera & light
    {
        /*if (m_IsCameraLocked)
        {
            rmt::Vector desiredTarget = m_CVPuppet->GetCameraTarget();

            rmt::Vector delta = desiredTarget;
            delta.Sub(m_CameraTarget);
            float mag = delta.NormalizeSafe();

            static const float cameraSpeed = 1.5f;  // m/s
            float maxMag = cameraSpeed * deltaTime * mag;
            if (mag > maxMag)
            {
                mag = maxMag;
            }

            delta.Scale(mag);
            m_CameraTarget.Add(delta);
            m_CameraTarget.x = desiredTarget.x;
            m_CameraTarget.z = desiredTarget.z;
        }*/

        m_Camera->SetTarget(m_CameraTarget);
        rmt::Matrix mY;
        mY.FillRotateY(m_CameraRotateY);
        rmt::Matrix mX;
        mX.FillRotateX(m_CameraRotateX);
        rmt::Vector cameraPos(0.0f, 0.0f, m_CameraDistance);
        cameraPos.Rotate(mX);
        cameraPos.Rotate(mY);
        cameraPos.Add(m_CameraTarget);
        m_Camera->SetPosition(cameraPos);

        rmt::Vector lightDir;
        lightDir = m_CameraTarget;
        lightDir.Sub(cameraPos);
        m_Light->SetDirection(lightDir);
    }

    //return rc;
	return true;
}

bool SPContext::Display()
{
    m_Context->BeginFrame();
    m_View->BeginRender();

    // render game context
	if ( g_Workspace )
	{
		g_Workspace->Display(m_Context);
	}

    // draw origin
    {
        rmt::Matrix m;
        m.Identity();
        DrawAxes(m, 0.5f);
    }

    m_View->EndRender();
    m_Context->EndFrame();

    //return rc;
	return true;
}

void SPContext::DrawAxes(const rmt::Matrix& m, float radius)
{
   rmt::Vector oldVtx[4] =
   {
      rmt::Vector(0,0,0),
      rmt::Vector(radius,0,0),
      rmt::Vector(0,radius,0),
      rmt::Vector(0,0,radius)
   };
   rmt::Vector newVtx[4];
   m.Transform(4, oldVtx, newVtx);

   pddiPrimStream* stream = p3d::pddi->BeginPrims(m_Shader, PDDI_PRIM_LINES, PDDI_V_C , 6);

   stream->Vertex((pddiVector*)newVtx, pddiColour(255,0,0));
   stream->Vertex((pddiVector*)(newVtx + 1), pddiColour(255,0,0));

   stream->Vertex((pddiVector*)newVtx, pddiColour(0,255,0));
   stream->Vertex((pddiVector*)(newVtx + 2), pddiColour(0,255,0));

   stream->Vertex((pddiVector*)newVtx, pddiColour(0,0,255));
   stream->Vertex((pddiVector*)(newVtx + 3), pddiColour(0,0,255));

   p3d::pddi->EndPrims(stream);
}

void SPContext::DrawLine(const rmt::Vector& a, const rmt::Vector& b, tColour c)
{
	pddiPrimStream* stream = p3d::pddi->BeginPrims(m_Shader, PDDI_PRIM_LINES, PDDI_V_C , 2 );
	stream->Vertex((pddiVector*)(&a), c);
	stream->Vertex((pddiVector*)(&b), c);
	p3d::pddi->EndPrims(stream);
}

void SPContext::RenderPose(tPose* pose)
{
    pose->Evaluate();

	int i;
	int startJoint = 0;
	for (i = startJoint; i < pose->GetNumJoint(); ++i)
	{
        tPose::Joint* joint = pose->GetJoint(i);
        tPose::Joint* parent = joint->parent;

        if (parent != 0)
        {
            DrawLine(parent->worldMatrix.Row(3), joint->worldMatrix.Row(3), tColour(255,255,255));
            DrawAxes(parent->worldMatrix, 0.02f);
        }
	}
}

void SPContext::MouseDown(int button, int shift, int x, int y)
{
    if (m_MouseCapture == 0)
    {
        SetCapture(m_HWnd);
        m_MouseCapture = 1;
    }

    m_MouseX = x;
    m_MouseY = y;
}

void SPContext::MouseMove(int button, int shift, int x, int y)
{
    if (m_MouseCapture == 0)
        return;
    if (GetCapture() != m_HWnd)
        return;

    int dx = x - m_MouseX;
    int dy = y - m_MouseY;
    m_MouseX = x;
    m_MouseY = y;

    if ((button & MK_LBUTTON) != 0)
    {
        if ((button & MK_MBUTTON) != 0)
        {
            CameraZoom(dx * 10);
        }
        else
        {
            CameraRotate(dx, dy);
        }
    }
    else if ((button & MK_MBUTTON) != 0)
    {
        CameraPan(dx, dy);
    }
}

void SPContext::MouseUp(int button, int shift, int x, int y)
{
    MouseMove(button, shift, x, y);

    if (m_MouseCapture == 0)
        return;

    ReleaseCapture();
    m_MouseCapture = 0;
}

void SPContext::MouseWheel(int scroll)
{
    CameraZoom(scroll);
}

void SPContext::CameraPan(int dx, int dy)
{
    RECT wndRect;
    GetWindowRect(m_HWnd, &wndRect);

    rmt::Vector v((float)-dx / (float)(wndRect.right - wndRect.left),
                  (float)dy / (float)(wndRect.bottom - wndRect.top), 0.0f);
    rmt::Vector a, b;
    m_Camera->ViewToWorld(v, &a, &b);
    b.Sub(a);
    b.NormalizeSafe();
    b.Scale(m_CameraDistance - m_Camera->GetNearPlane());
    b.Add(a);
    m_CameraTarget = b;
}

void SPContext::CameraZoom(int dz)
{
	m_CameraDistance += ((float)-dz * 0.001f * m_CameraDistance);

	if (m_CameraDistance < 0.1f)
	{
		m_CameraDistance = 0.1f;
	}
}

void SPContext::CameraRotate(int dx, int dy)
{
    m_CameraRotateX += ((float)-dy * 0.01f);

    if (m_CameraRotateX > rmt::DegToRadian(89.9f))
    {
        m_CameraRotateX = rmt::DegToRadian(89.9f);
    }

    if (m_CameraRotateX < rmt::DegToRadian(-89.9f))
    {
        m_CameraRotateX = rmt::DegToRadian(-89.9f);
    }

    m_CameraRotateY += ((float)dx * 0.01f);
}

float SPContext::SimulationGetFPS() const
{
    float fps = 0.0f;

    for (int i = 0; i < MAX_FPS_COUNT; ++i)
    {
        fps += m_FPS[i];
    }

    fps /= (float)MAX_FPS_COUNT;

    if (!rmt::Epsilon(fps, 0.0f))
    {
        fps = 1.0f / fps;
    }

    return fps;
}

void SPContext::SimulationSetRate(float simRate)
{
    m_SimRate = simRate;

    if (m_SimRate < 0.0f)
    {
        m_SimRate = 0.0f;
    }
}

bool SPContext::GetEntityName(tEntity* entity, char* name, int maxLen)
{
    if (maxLen > 0)
    {
        name[0] = 0;
    }

    if (entity == 0)
        return false;

    if (entity->GetName() != 0)
    {
        _snprintf(name, maxLen, "%s", entity->GetName());
    }
    else
    {
        _snprintf(name, maxLen, "0x%016I64x", entity->GetUID());
    }

    if (maxLen > 0)
    {
        name[maxLen - 1] = 0;
    }

    return true;
}

void SPContext::InventoryClear()
{
    if (m_Context != 0)
    {
        m_Context->GetInventory()->RemoveAllElements();
    }
}

int SPContext::InventoryGetEntityCount() const
{
    if (m_Context == 0)
        return 0;

    int entityCount = 0;
	/*
    for (int s = 0; s < m_Context->GetInventory()->GetSectionCount(); ++s)
    {
        entityCount += m_Context->GetInventory()->GetSectionByIndex(s)->GetElementCount();
    }
	*/

    return entityCount;
}

bool SPContext::InventoryGetEntityName(int index,
                                       char* name, int nameLen,
                                       char* type, int typeLen) const
{
    int entityCount = 0;

	/*
    for (int s = 0; s < m_Context->GetInventory()->GetSectionCount(); ++s)
    {
        tEntityTable::RawIterator itor(m_Context->GetInventory()->GetSectionByIndex(s));

        tEntity* obj = itor.First();
        while (obj)
        {
            if (entityCount == index)
            {
                GetEntityName(obj, name, nameLen);
                _snprintf(type, typeLen, "%s", typeid(*obj).name());
                type[typeLen - 1] = '\0';

                return true;
            }

            ++entityCount;
            obj = itor.Next();
        }
    }
	*/

    return false;
}

void SPContext::SetBackgroundColour(int r , int g , int b )
{
	m_View->SetBackgroundColour( tColour( r , g , b ) );
}


//---------------------------------------------------------------------------
// SPContext - DLL interface
//---------------------------------------------------------------------------

int SP_CALLCONV SPContextOpen(HWND hwnd)
{
    P3DASSERT(g_SPContext == 0);
    if (g_SPContext != 0)
        return -1;

    g_SPContext = new SPContext(hwnd);
    if (!g_SPContext->Open())
    {
        delete g_SPContext;
        g_SPContext = 0;
        return -1;
    }

    return 1;
}

int SP_CALLCONV SPContextClose()
{
    if (g_SPContext == 0)
        return 0;

    if (!g_SPContext->Close())
    {
        delete g_SPContext;
        g_SPContext = 0;
        return -1;
    }

    delete g_SPContext;
    g_SPContext = 0;
    return 1;
}

int SP_CALLCONV SPContextViewResize(int w, int h)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->ViewResize(w, h);
    return 1;
}

int SP_CALLCONV SPContextIsPDDIStatsEnabled()
{
    if (p3d::pddi == 0)
        return -1;
    return p3d::pddi->IsStatsOverlayEnabled();
}

int SP_CALLCONV SPContextSetIsPDDIStatsEnabled(int statsEnabled)
{
    if (p3d::pddi == 0)
        return -1;
    p3d::pddi->EnableStatsOverlay(statsEnabled != 0);
    return 1;
}

int SP_CALLCONV SPContextAdvance()
{
    if (g_SPContext == 0)
        return -1;

    return g_SPContext->Advance();
}

int SP_CALLCONV SPContextDisplay()
{
    if (g_SPContext == 0)
        return -1;

    return g_SPContext->Display();
}

int SP_CALLCONV SPContextMouseDown(int button, int shift, int x, int y)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->MouseDown(button, shift, x, y);
    return 0;
}

int SP_CALLCONV SPContextMouseMove(int button, int shift, int x, int y)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->MouseMove(button, shift, x, y);
    return 0;
}

int SP_CALLCONV SPContextMouseUp(int button, int shift, int x, int y)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->MouseUp(button, shift, x, y);
    return 0;
}

int SP_CALLCONV SPContextMouseWheel(int scroll)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->MouseWheel(scroll);
    return 0;
}

float SP_CALLCONV SPSimulationGetFPS()
{
    if (g_SPContext == 0)
        return 0.0f;

    return g_SPContext->SimulationGetFPS();
}

float SP_CALLCONV SPSimulationGetRate()
{
    if (g_SPContext == 0)
        return 0.0f;

    return g_SPContext->SimulationGetRate();
}

int SP_CALLCONV SPSimulationSetRate(float rate)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->SimulationSetRate(rate);
    return 0;
}

int SP_CALLCONV SPContextGetCameraLock()
{
    if (g_SPContext == 0)
        return -1;

    return g_SPContext->IsCameraLocked();
}

int SP_CALLCONV SPContextSetCameraLock(int cameraLock)
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->SetIsCameraLocked(cameraLock != 0);
    return 0;
}

int SP_CALLCONV SPInventoryClear()
{
    if (g_SPContext == 0)
        return -1;

    g_SPContext->InventoryClear();
    return 0;
}

int SP_CALLCONV SPInventoryGetEntityCount()
{
    if (g_SPContext == 0)
        return -1;

    return g_SPContext->InventoryGetEntityCount();
}

int SP_CALLCONV SPInventoryGetEntityName(int index, char* name, int nameLen, char* type, int typeLen)
{
    if (g_SPContext == 0)
        return -1;

    if (!g_SPContext->InventoryGetEntityName(index, name, nameLen, type, typeLen))
    {
        return -1;
    }

    return 0;
}

int SP_CALLCONV SPSetBackgroundColour( int r , int g , int b )
{
    if (g_SPContext == 0)
        return 0;

    g_SPContext->SetBackgroundColour( r , g , b );
	return 1;
}

// End of file.