#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "bh_types.h"

#include "weapons.h"

#include "dynamics.h"

#include "pvisible.h"

#include "lift.h"

#include <assert.h>

#include <stdlib.h>

extern SCENEMODULE MainScene;

LIFT_CONTROL_BLOCK EC_Lift_Ctrl;

MODULE Old_Pos_Module;

void LiftBehaveInit(void* bhdata, STRATEGYBLOCK* sbptr)

{

    MODULE * my_mod;

    LIFT_BEHAV_BLOCK *lift_bhv = malloc(sizeof(LIFT_BEHAV_BLOCK));

    if(!lift_bhv) 

    {

        RemoveBehaviourStrategy(sbptr);

        return;

    }

    sbptr->dataptr = lift_bhv;

    lift_bhv->bhvr_type = I_BehaviourLift;

     LIFT_STATION* lift_stn = &lift_bhv->lift_station;

    LIFT_TOOLS_TEMPLATE* lift_tt = (LIFT_TOOLS_TEMPLATE*)bhdata;

    // Copy the name over

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

    {

        MREF mref = lift_tt->my_module;

        ConvertModuleNameToPointer (&mref, MainScene.sm_marray);

        my_mod = mref.mref_ptr;

    }

    assert (my_mod);

    my_mod->m_sbptr = sbptr;

    sbptr->moptr = my_mod;

    // loaded data - first the station

    COPY_NAME(lift_stn->lift_call_switch_name, lift_tt->call_switch_name);

    COPY_NAME(lift_stn->lift_door_name, lift_tt->lift_door_name);

    COPY_NAME(lift_stn->lift_floor_switch_name, lift_tt->lift_floor_switch_name);

    COPY_NAME(lift_stn->my_sb_name, lift_tt->my_module_name);

    lift_stn->num_floor =    lift_tt->num_floor;

    lift_stn->orient = lift_tt->orient;

    // fill in the rest of the stn data;

    lift_stn->lift_call_switch = NULL;    

    lift_stn->lift_door = NULL;    

    lift_stn->lift_floor_switch = NULL;    

    lift_stn->lift_module = sbptr->moptr;

    lift_stn->starting_station = (lift_tt->lift_flags & LiftFlag_Here);

    lift_stn->called = 0;

    // fill in the behaviour block

    lift_bhv->control_sb = NULL;

    lift_bhv->controller = lift_tt->controller;

    COPY_NAME(lift_bhv->control_sb_name, lift_tt->control_sb_name);

    if(lift_bhv->controller)

    {

        LIFT_CONTROL_BLOCK* lcont = malloc(sizeof(LIFT_CONTROL_BLOCK));

        if(!lcont)

        {

            RemoveBehaviourStrategy(sbptr);

            return;

        }

        lift_bhv->lift_control = lcont;

        // fill in the number of floors

        lcont->num_stations = lift_tt->num_stations;

        lcont->lift_stations = malloc(sizeof(LIFT_STATION*)*lcont->num_stations);                                            

        if(!lcont->lift_stations) 

        {

            RemoveBehaviourStrategy(sbptr);

            return;

        }

        //and init that array

        {

            int i=0;

            while(i < lcont->num_stations)

            {

                *(lcont->lift_stations + i) = NULL;

                i++;

            }

        }

        // fill in the rest of the data

        *(lcont->lift_stations + lift_stn->num_floor) = lift_stn;

        lcont->dest_station = -1;

        lcont->delay_at_floor = 0;

        lcont->delay_between_floors = 0;

        lcont->motion = I_going_down;

        lcont->state = I_ls_waiting;

        lcont->curr_station = -1;

        lcont->prev_station = -1;

        lcont->SoundHandle = SOUND_NOACTIVEINDEX;

        lcont->floor_switches_fixed = (lift_tt->lift_flags & LiftFlag_NoTel);

    }

    else

    {

        lift_bhv->lift_control = NULL;

    }

}

void TeleportContents(MODULE* new_pos, MODULE* old_pos, int floor_switches_fixed)

{

    //this used within level - find objects in module

    // all will have sbs

    int i;

    VECTORCH mod_offset;

    mod_offset.vx = new_pos->m_world.vx - old_pos->m_world.vx;

    mod_offset.vy = new_pos->m_world.vy - old_pos->m_world.vy;

    mod_offset.vz = new_pos->m_world.vz - old_pos->m_world.vz;

    int max_x = old_pos->m_maxx + old_pos->m_world.vx;

    int min_x = old_pos->m_minx + old_pos->m_world.vx;

    int max_y = old_pos->m_maxy + old_pos->m_world.vy;

    int min_y = old_pos->m_miny + old_pos->m_world.vy;

    int max_z = old_pos->m_maxz + old_pos->m_world.vz;

    int min_z = old_pos->m_minz + old_pos->m_world.vz;

    int dest_max_x = new_pos->m_maxx + new_pos->m_world.vx -200;

    int dest_min_x = new_pos->m_minx + new_pos->m_world.vx +200;

    int dest_max_y = new_pos->m_maxy + new_pos->m_world.vy -200;

    int dest_min_y = new_pos->m_miny + new_pos->m_world.vy +200;

    int dest_max_z = new_pos->m_maxz + new_pos->m_world.vz -200;

    int dest_min_z = new_pos->m_minz + new_pos->m_world.vz +200;

    for(i = 0; i < NumActiveStBlocks; i++)

    {

        DYNAMICSBLOCK    *dynptr;            

        STRATEGYBLOCK    *sbptr = ActiveStBlockList[i];

        if(!(dynptr = sbptr->DynPtr))

            continue;

        if(floor_switches_fixed)

        {

            switch(sbptr->type)

            {

                case I_BehaviourInanimateObject:

                    if (((INANIMATEOBJECT_STATUSBLOCK*)sbptr->dataptr)->typeId)

                        break;

                case I_BehaviourBinarySwitch:

                case I_BehaviourLinkSwitch:

                    continue; 

                default:

                break;

            }

        }

        VECTORCH obj_world = dynptr->Position;

        if(obj_world.vx < max_x)

            if(obj_world.vx > min_x)

                if(obj_world.vz < max_z)

                    if(obj_world.vz > min_z)

                        if(obj_world.vy < max_y)

                            if(obj_world.vy > min_y)

                            {

                                dynptr->Position.vx += mod_offset.vx; 

                                dynptr->Position.vy += mod_offset.vy; 

                                dynptr->Position.vz += mod_offset.vz; 

                                dynptr->PrevPosition.vx += mod_offset.vx; 

                                dynptr->PrevPosition.vy += mod_offset.vy; 

                                dynptr->PrevPosition.vz += mod_offset.vz; 

                                //make sure new location is inside destination module

                                if(!dynptr->IsStatic)

                                {

                                    if(dynptr->Position.vx < dest_min_x) dynptr->Position.vx = dest_min_x;

                                    if(dynptr->Position.vy < dest_min_y) dynptr->Position.vy = dest_min_y;

                                    if(dynptr->Position.vz < dest_min_z) dynptr->Position.vz = dest_min_z;

                                    if(dynptr->Position.vx > dest_max_x) dynptr->Position.vx = dest_max_x;

                                    if(dynptr->Position.vy > dest_max_y) dynptr->Position.vy = dest_max_y;

                                    if(dynptr->Position.vz > dest_max_z) dynptr->Position.vz = dest_max_z;

                                    if(dynptr->PrevPosition.vx < dest_min_x) dynptr->PrevPosition.vx = dest_min_x;

                                    if(dynptr->PrevPosition.vy < dest_min_y) dynptr->PrevPosition.vy = dest_min_y;

                                    if(dynptr->PrevPosition.vz < dest_min_z) dynptr->PrevPosition.vz = dest_min_z;

                                    if(dynptr->PrevPosition.vx > dest_max_x) dynptr->PrevPosition.vx = dest_max_x;

                                    if(dynptr->PrevPosition.vy > dest_max_y) dynptr->PrevPosition.vy = dest_max_y;

                                    if(dynptr->PrevPosition.vz > dest_max_z) dynptr->PrevPosition.vz = dest_max_z;

                                }

                                if(sbptr->maintainVisibility)

                                    sbptr->containingModule = new_pos;

                            }

    }

}

void LiftBehaveFun(STRATEGYBLOCK* sbptr)

{

     assert(sbptr);

    LIFT_BEHAV_BLOCK *lift_bhv = (LIFT_BEHAV_BLOCK*)sbptr->dataptr;

    assert((lift_bhv->bhvr_type == I_BehaviourLift));

    LIFT_CONTROL_BLOCK *lift_ctrl = lift_bhv->lift_control;

    /* ALL the lift modules have a Strategy block that contains inforamtion

         about that particular location. Only one points to the LIFT CONTROL

         BLOCK

    */

    /* the lifts will work between envs as well as on the same env 

         so the control of the doors in the other envs sin't actually set,

         but a record of the postion is maintained

    */

    if(lift_bhv->controller)

       {

           // HACK    - RWH - if this is true the data is broken and this fix won't always work

           if(lift_ctrl->curr_station == -1)

               lift_ctrl->curr_station = 0;

           switch(lift_ctrl->state)

        {

            case I_ls_waiting:

            {

                /*** find dest and set movement direction this is always the

                same even if the lift is on a different floor ***/

                int lower_station = -1;

                int upper_station = -1;

                int i;

                LIFT_STATION *lift_stn;

                /**** find the nearest floors selected ****/

                // search up and down

                for(i = lift_ctrl->curr_station; (i >= 0) && (lower_station == -1); i --)

                {

                    lift_stn = lift_ctrl->lift_stations[i];

                    if(lift_stn->called)

                        upper_station = i;    // higher floors have lower nums

                }

                for(i = lift_ctrl->curr_station; (i < lift_ctrl->num_stations) && (upper_station == -1); i ++)

                {

                    lift_stn = lift_ctrl->lift_stations[i];

                    if(lift_stn->called)

                        lower_station = i;      // lower floors have higher nums

                }

                /****** set the    destination and the motion direction ****/

                if(lift_ctrl->motion == I_going_down)// higher nums

                {

                    if(lower_station != -1)

                    {

                        lift_ctrl->dest_station = lower_station;

                    }

                    else

                    {

                        lift_ctrl->dest_station = upper_station;

                        lift_ctrl->motion = I_going_up;

                    }

                }

                else if(lift_ctrl->motion == I_going_up) // lower nums

                {

                    if(upper_station != -1)

                    {

                        lift_ctrl->dest_station = upper_station;

                    }

                    else

                    {

                        lift_ctrl->dest_station = lower_station;

                        lift_ctrl->motion = I_going_down;

                    }

                }

                // now we have a station to go to, we start the lift in motion

                // unless we have just pressed the current floor switch again

                if(lift_ctrl->dest_station == lift_ctrl->curr_station)

                {

                    // we have just called the lift to the same place

                    lift_ctrl->dest_station = -1;

                    lift_stn = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                    lift_stn->called = 0;

                }

                else if(lift_ctrl->dest_station != -1)

                {

                    // if there is a dest, set the lift to go

                    // close current stations 

                    lift_stn = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                    {

                        lift_ctrl->prev_station = lift_ctrl->curr_station;

                        if(lift_stn->lift_door)

                        {

                            // no door - must be on another env

                            RequestState(lift_stn->lift_door, 0, 0);

                        }

                        lift_ctrl->state = I_ls_closing_door;

                    }

                }

            }

            break;

            case I_ls_closing_door:

            {

                // lift station for the current lift position has to 

                // have a closed door

                LIFT_STATION *pos_stn = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                //MODULE* mptr = pos_stn->lift_module;

                // deal with the fact that the lift is in a different env

                // close the door before we change state to moving                         

                if(!GetState(pos_stn->lift_door))

                {

                    lift_ctrl->state = I_ls_moving;

                    lift_ctrl->delay_between_floors = LIFT_MOVE_DELAY;

                    RequestState(pos_stn->lift_call_switch, 0, 0);

                    if(pos_stn->lift_floor_switch)

                        RequestState(pos_stn->lift_floor_switch, 0, 0);

                    //what if there is a bad guy in the lift - if there is open the door

                    //and reset all the switches and stations

                }

            }

            break;

            case I_ls_moving:

            {

                //int curr_station_num = lift_ctrl->curr_station;

                //LIFT_STATION *pos_stn = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                //MODULE* mptr = pos_stn->lift_module;

                lift_ctrl->delay_between_floors -= NormalFrameTime;

                // TRAP CHANGE OF ENVIRONMENT

                // we need to trap it here so we don't have the delay

                // between floors. However. The trap should make sure it is the nex array pos

                if(lift_ctrl->delay_between_floors < 0)

                {

                    if(lift_ctrl->motion == I_going_up)

                        lift_ctrl->curr_station--;

                    else

                        lift_ctrl->curr_station++;

                    assert(lift_ctrl->curr_station >= 0);

                    if(lift_ctrl->curr_station == lift_ctrl->dest_station)

                    {

                        // at destination

                        LIFT_STATION *lift_stn_new = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                        LIFT_STATION *lift_stn_old = lift_ctrl->lift_stations[lift_ctrl->prev_station];

                        MODULE * new_pos = lift_stn_new->lift_module;

                        MODULE * old_pos = lift_stn_old->lift_module;

                        lift_ctrl->dest_station = -1;

                        lift_ctrl->state = I_ls_opening_door;                    

                        /* roxby: i have taken this out - patrick */

                        /* assert(mptr); */

                        Sound_Stop(lift_ctrl->SoundHandle);

                        //  door open

                        RequestState(lift_stn_new->lift_door, 1, 0);

                        lift_stn_new->called = 0;

                        if(old_pos)

                        {    

                            // if we don't have an old pos, we must

                            // be coming from another env

                            TeleportContents(new_pos, old_pos,lift_ctrl->floor_switches_fixed);

                        }

                    }

                    else 

                    {

                        // futher to go - move along now

                        lift_ctrl->delay_between_floors += LIFT_MOVE_DELAY;

                     }

                }

            }

            break;

            case I_ls_opening_door:

            {

                LIFT_STATION *lift_stn_new = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                if(GetState(lift_stn_new->lift_door))

                {

                    lift_ctrl->state = I_ls_delay_at_floor;

                    lift_ctrl->delay_at_floor = LIFT_FLOOR_DELAY;

                }

            }

            break;

            case I_ls_delay_at_floor:

            {

                lift_ctrl->delay_at_floor -= NormalFrameTime;

                if(lift_ctrl->delay_at_floor < 0)

                {

                    // turn on the floor lights

                    LIFT_STATION *lift_stn = lift_ctrl->lift_stations[lift_ctrl->curr_station];

                    RequestState(lift_stn->lift_call_switch, 1, 0);

                    if(lift_stn->lift_floor_switch_name[0] || lift_stn->lift_floor_switch_name[4])

                        RequestState(lift_stn->lift_floor_switch, 1, 0);

                    lift_ctrl->state = I_ls_waiting;

                    lift_ctrl->dest_station = -1;

                }

            }

            break;

            default:

                assert(2<1);

        }

       }

}