#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "switchdoor.h"

#include "liftdoor.h"

#include "savegame.h"

#include <assert.h>

#include <stdlib.h>

extern void UpdateMorphing(MORPHCTRL *mcptr);

extern int AnythingInMyModule(MODULE* my_mod);

extern SCENEMODULE MainScene;

void LiftDoorBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)

{

    MODULE * my_mod;

    LIFT_DOOR_BEHAV_BLOCK *doorbhv = malloc(sizeof(LIFT_DOOR_BEHAV_BLOCK));

    if (NULL == doorbhv) 

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->dataptr = doorbhv;

    doorbhv->bhvr_type = I_BehaviourLiftDoor;

    LIFT_DOOR_TOOLS_TEMPLATE *doortt = (LIFT_DOOR_TOOLS_TEMPLATE*)bhdata;    

    MORPHCTRL* morphctrl = malloc(sizeof(MORPHCTRL));

    if (NULL == morphctrl)

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    MORPHHEADER* morphheader = malloc(sizeof(MORPHHEADER));

    if (NULL == morphheader)

    {

        free(morphctrl);

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    MORPHFRAME* morphframe = malloc(sizeof(MORPHFRAME));

    if (NULL == morphframe)

    {

        free(morphctrl);

        free(morphheader);

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    morphframe->mf_shape1 = doortt->shape_open;

    morphframe->mf_shape2 = doortt->shape_closed;

    morphheader->mph_numframes = 1;

    morphheader->mph_maxframes = ONE_FIXED;

    morphheader->mph_frames = morphframe;

    morphctrl->ObMorphCurrFrame = 0;

    morphctrl->ObMorphFlags = 0;

    morphctrl->ObMorphSpeed = 0;

    morphctrl->ObMorphHeader = morphheader;

    // Copy the name over

    COPY_NAME (sbptr->SBname, doortt->nameID);

    // Setup module ref

    {

        MREF mref = doortt->my_module;

        ConvertModuleNameToPointer (&mref, MainScene.sm_marray);

        my_mod = mref.mref_ptr;

    }

    assert (my_mod);

    my_mod->m_sbptr = sbptr;

    sbptr->moptr = my_mod;

    doorbhv->door_state = doortt->state;

    doorbhv->PDmctrl = morphctrl;

    doorbhv->door_closing_speed = doortt->door_closing_speed;

    doorbhv->door_opening_speed = doortt->door_opening_speed;

    // all lift doors have a closed starting state except the

    // one where the lift is - fill in other data

    sbptr->morphctrl = doorbhv->PDmctrl;

    if(doorbhv->door_state == I_door_open)

    {

        sbptr->morphctrl->ObMorphCurrFrame = 0; 

        OpenDoor(sbptr->morphctrl, DOOR_OPENFASTSPEED);    

    }

    else

    {

        assert(doorbhv->door_state == I_door_closed);

        sbptr->morphctrl->ObMorphCurrFrame = 1; 

        CloseDoor(sbptr->morphctrl, DOOR_CLOSEFASTSPEED);    

    }

    doorbhv->request_state = doorbhv->door_state;

    // copy data into relevant structures

    sbptr->morphctrl = doorbhv->PDmctrl;

    if(sbptr->moptr)

        sbptr->moptr->m_flags |= m_flag_open;

      doorbhv->SoundHandle = SOUND_NOACTIVEINDEX;

}

void LiftDoorBehaveFun(STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    LIFT_DOOR_BEHAV_BLOCK *doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbptr->dataptr;

    assert((doorbhv->bhvr_type == I_BehaviourLiftDoor));

    MORPHCTRL *mctrl = doorbhv->PDmctrl;

    assert(mctrl);

    MODULE *mptr = sbptr->moptr;

    assert(mptr);

    /* update morphing.... */

    UpdateMorphing(mctrl);

     switch(doorbhv->door_state)

    {

        case I_door_opening:

        {    

            mptr->m_flags |= m_flag_open;

            if(mctrl->ObMorphFlags & mph_flag_finished)        

            {

                if (doorbhv->SoundHandle != SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOOREND,"d",&mptr->m_world);

                    Sound_Stop(doorbhv->SoundHandle);

                }

                doorbhv->door_state = I_door_open;

            }

        }

        break;

        case I_door_closing:

        {

            if(mctrl->ObMorphFlags & mph_flag_finished)

            {

                if (doorbhv->SoundHandle != SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOOREND, "d", &mptr->m_world);

                    Sound_Stop(doorbhv->SoundHandle);

                }

                doorbhv->door_state = I_door_closed;

                mptr->m_flags &= ~m_flag_open;

            }

            else if(AnythingInMyModule(sbptr->moptr))

            {

                if (doorbhv->SoundHandle == SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOORSTART, "d", &mptr->m_world);

                    Sound_Play(SID_DOORMID, "del", &mptr->m_world, &doorbhv->SoundHandle);

                }

                OpenDoor(mctrl, doorbhv->door_opening_speed);

                doorbhv->door_state = I_door_opening;

                mptr->m_flags |= m_flag_open;

            }                            

        }

        break;

        case I_door_open:

        {

            mptr->m_flags |= m_flag_open;

            if(doorbhv->request_state == I_door_closed)

            {

                if (doorbhv->SoundHandle == SOUND_NOACTIVEINDEX)

                {

                     Sound_Play(SID_DOORSTART,"d",&mptr->m_world);

                     Sound_Play(SID_DOORMID,"del",&mptr->m_world,&doorbhv->SoundHandle);

                }

                CloseDoor(mctrl, doorbhv->door_closing_speed);

                doorbhv->door_state = I_door_closing;

            }

        }

        break;

        case I_door_closed:

        {

            mptr->m_flags &= ~m_flag_open;

            if(doorbhv->request_state == I_door_open)

            {

                if (doorbhv->SoundHandle == SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOORSTART,"d",&mptr->m_world);

                    Sound_Play(SID_DOORMID,"del",&mptr->m_world,&doorbhv->SoundHandle);

                }

                OpenDoor(mctrl, doorbhv->door_opening_speed);

                doorbhv->door_state = I_door_opening;

                mptr->m_flags |= m_flag_open;

            }

        }

        break;

        default:

            assert(1==0);

    }

}

/*--------------------**

** Loading and Saving **

**--------------------*/

typedef struct lift_door_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    DOOR_STATES door_state;

    DOOR_STATES request_state;

    //from the morph control

    int ObMorphCurrFrame;

    int ObMorphFlags;

    int ObMorphSpeed;

} LIFT_DOOR_SAVE_BLOCK;

void LoadStrategy_LiftDoor(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    LIFT_DOOR_SAVE_BLOCK* block = (LIFT_DOOR_SAVE_BLOCK*) header; 

    if(header->size != sizeof(*block))

        return;

    //find the existing strategy block

    STRATEGYBLOCK* sbPtr = FindSBWithName(block->header.SBname);

    if(!sbPtr)

        return;

    //make sure the strategy found is of the right type

    if(sbPtr->type != I_BehaviourLiftDoor)

        return;

    LIFT_DOOR_BEHAV_BLOCK *doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    doorbhv->request_state = block->request_state;

    doorbhv->door_state = block->door_state;

    doorbhv->PDmctrl->ObMorphCurrFrame = block->ObMorphCurrFrame;

    doorbhv->PDmctrl->ObMorphFlags = block->ObMorphFlags;

    doorbhv->PDmctrl->ObMorphSpeed = block->ObMorphSpeed;

    Load_SoundState(&doorbhv->SoundHandle);

}

void SaveStrategy_LiftDoor(STRATEGYBLOCK* sbPtr)

{

    LIFT_DOOR_SAVE_BLOCK *block;

    LIFT_DOOR_BEHAV_BLOCK *doorbhv = (LIFT_DOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    block->request_state = doorbhv->request_state;

    block->door_state = doorbhv->door_state;

    block->ObMorphCurrFrame = doorbhv->PDmctrl->ObMorphCurrFrame;

    block->ObMorphFlags = doorbhv->PDmctrl->ObMorphFlags;

    block->ObMorphSpeed = doorbhv->PDmctrl->ObMorphSpeed;

    Save_SoundState(&doorbhv->SoundHandle);

}