#include "GlobalFunc.h"
#include "T2Archive.h"
#include "T2ElvModuleList.h"
#include "T2FloorInfo.h"
#include "T2Mover.h"
#include "T2MoverCEArray.h"
#include "T2MoverDef.h"
#include "T2MoverModule.h"
#include "T2MoverModuleList.h"
#include "T2Name.h"
#include "T2NameList.h"
#include "T2People.h"
#include "T2PeopleLinkIterator.h"
#include "T2Request.h"
#include "T2RequestIDArray.h"
#include "T2RouteNavigator.h"
#include "T2StairModuleList.h"
#include "T2TemplatePluginList.h"
#include "T2Tenant.h"
#include "T2TowerDoc.h"
#include "T2TowerMainView.h"
#include "UT2Coordinate.h"

T2Mover::T2Mover() {
    mShowShaft = true;
    mLength = 0;
    mReqIDArray = NULL;
    mShowShaft = true;
    mCheckRequest = false;
    mWaitCount = 0;
    mCapacity = 0;
    mMaxModule = 0;
    mModuleList = NULL;

    mReqIDArray = new T2RequestIDArray;
#line 27
    _ASSERT(mReqIDArray != NULL);
}

/*virtual*/ T2Mover::~T2Mover() {
    if (mReqIDArray)
        delete mReqIDArray;
    if (mModuleList)
        delete mModuleList;
}

/*virtual*/ void T2Mover::SetUsed(BOOL used) {
    if (!used) {
        T2TowerDoc *theTowerDoc = GetCurrentT2TowerDoc();
#line 48
        _ASSERT(theTowerDoc != NULL);

        T2NameList *theNameDB = theTowerDoc->mNameDB;
#line 51
        _ASSERT(theNameDB != NULL);

        T2Name *theName = theNameDB->Search(this, true);
        if (theName) {
            theNameDB->RemoveName(theName);
            delete theName;
        }

        theName = theNameDB->Search(this, false);
        if (theName) {
            theNameDB->RemoveName(theName);
            delete theName;
        }

        if (IsStair() && mModuleList) {
            LArrayIterator iterator(*mModuleList);
            T2MoverModule *theModule;
            while (iterator.Next(&theModule)) {
                theName = theNameDB->Search(theModule, true);
                if (theName) {
                    theNameDB->RemoveName(theName);
                    delete theName;
                }

                theName = theNameDB->Search(theModule, false);
                if (theName) {
                    theNameDB->RemoveName(theName);
                    delete theName;
                }
            }
        }

        if (mModuleList) {
            delete mModuleList;
            mModuleList = NULL;
        }

        if (mReqIDArray)
            mReqIDArray->AllClear();
    }

    T2Equip::SetUsed(used);
}

BOOL T2Mover::InitMover(T2MoverDef* moverDef, const RECT& baseRect, unsigned int valiation) {
    BOOL result = true;

    T2Equip::InitEquip(moverDef, baseRect, valiation);

    mStatus = kMoverStatus0;
    mCEArray = new T2MoverCEArray;
    mMaxModule = moverDef->GetMaxModule();
    mLength = moverDef->mHeight;
    mWaitCount = moverDef->GetDefaultWait();
    mShowShaft = true;

    if (mReqIDArray) {
        mReqIDArray->Init(baseRect);

        RECT addSize;
        moverDef->GetAddSize(addSize);
        UT2Coordinate::AddRect(mArea, addSize);
    } else {
        result = false;
    }

    return result;
}

BOOL T2Mover::InitStair(T2MoverDef* moverDef, const RECT& baseRect, unsigned int valiation) {
    BOOL result = true;

    InitMover(moverDef, baseRect, 0);

    mModuleList = new T2StairModuleList;
    if (mModuleList) {
        result = mModuleList->Init(moverDef, baseRect);
    } else {
        result = false;
    }

    return result;
}

BOOL T2Mover::InitElevator(T2MoverDef* moverDef, const RECT& baseRect, unsigned int valiation) {
    BOOL result = true;

    InitMover(moverDef, baseRect, valiation);

    mModuleList = new T2ElvModuleList;
    if (mModuleList) {
        result = mModuleList->Init(moverDef, baseRect);
    } else {
        result = false;
    }

    return result;
}

void T2Mover::GetTypicalName(CString& outStr) const {
    T2EquipDef *equipDef = GetEquipDef();
    if (equipDef)
        equipDef->GetName(outStr, 0);
    else
        outStr = "";
}

/*virtual*/ PROCCODE T2Mover::DoDestruct(T2TowerDoc* towerDoc, POINT pt, RECT& rect) {
    PROCCODE result = GetEquipDef()->DoDestructProc(towerDoc, this, pt, rect);

    if (result == ProcCode_0) {
        PARTCODE partCode = GetPartFromPoint(towerDoc, pt, NULL);
        if (partCode == PartCode_2) {
            GetEquipArea(rect);
            T2FloorInfo *theFloorInfo = towerDoc->mFloorInfo;

            for (int p = 0; p < mLength; p++) {
                if (IsStopPosition(p))
                    RemoveStopBoth(towerDoc, p);
            }

            theFloorInfo->FillMoverID(rect, 0);
            theFloorInfo->UpdeteRequestByRemoveMover(rect);

            GetEquipDef()->DestructFinish(towerDoc, this);
            SetUsed(false);
            return ProcCode_1;
        } else if (partCode == PartCode_4) {
            GetEquipArea(rect);
            return ProcCode_1;
        } else {
            return ProcCode_1;
        }
    }

    return result;
}

/*virtual*/ BOOL T2Mover::Destruct(T2TowerDoc* towerDoc, CRect& rect) {
    GetEquipArea(rect);

    T2FloorInfo *theFloorInfo = towerDoc->towerDoc_vf12C();
    mModuleList->Destruct(towerDoc);

    for (int p = 0; p < mLength; p++) {
        if (IsStopPosition(p))
            RemoveStopBoth(towerDoc, p);
    }

    theFloorInfo->FillMoverID(rect, 00);
    theFloorInfo->UpdeteRequestByRemoveMover(rect);

    SetUsed(false);

    BOOL done = true;

    towerDoc->towerDoc_vf124()->MoverRemoved(this, 1);

    return done;
}

/*virtual*/ void T2Mover::Draw(T2TowerDoc* towerDoc, const RECT& rect) {
    if (GetEquipDef())
        GetEquipDef()->DrawProc(this, mArea, towerDoc);
}

int T2Mover::GetNumStop() const {
    int count = 0;

    for (int p = 0; p < mLength; p++) {
        if (IsStopPosition(p))
            count++;
    }

    return count;
}

void T2Mover::AddStopBoth(T2TowerDoc* towerDoc, int position) {
    BOOL ok = false;
    T2FloorInfo *theFloorInfo = towerDoc->towerDoc_vf12C();

    ok |= AddStop(theFloorInfo, position, ERequestUpDown_0);
    ok |= AddStop(theFloorInfo, position, ERequestUpDown_1);

    if (mModuleList && ok)
        mModuleList->StopAdded(towerDoc, this, position);
}

BOOL T2Mover::AddStop(T2FloorInfo* floorInfo, int position, ERequestUpDown upDown) {
    BOOL result = false;

    POINT theNewStopPt = PositionToStopPt(position, upDown);
    T2Tenant *theFloor = floorInfo->GetFloor(theNewStopPt.y, theNewStopPt.x);

    if (theFloor) {
        CRect rect;
        theFloor->GetEquipArea(rect);

        if (rect.Height() == 1 || theNewStopPt.y == (rect.bottom - 1)) {
            if (!IsStopPosition(position))
                AddCrossEquipID(floorInfo, position);

            if (mReqIDArray) {
                T2Request *theRequest = floorInfo->FindUnusedRequest();
                if (theRequest) {
                    mReqIDArray->SetRequestIDAt(position, upDown, theRequest->GetRequestID());
                    POINT stopPt2 = PositionToStopPt(position, upDown);
                    theRequest->InitRequest(floorInfo, mEquipID, stopPt2, upDown);
                }
            }

            result = true;
        }
    }

    return result;
}

void T2Mover::RemoveStopBoth(T2TowerDoc* towerDoc, int position) {
    RemoveStop(towerDoc, position, ERequestUpDown_0);
    RemoveStop(towerDoc, position, ERequestUpDown_1);

    RemoveCrossEquipID(towerDoc->towerDoc_vf12C(), position);
    mReqIDArray->StopRemoved(towerDoc, PositionToUnit(position));

    if (mModuleList)
        mModuleList->StopRemoved(towerDoc, this, position);
}

void T2Mover::RemoveStop(T2TowerDoc* towerDoc, int position, ERequestUpDown upDown) {
    if (mReqIDArray)
        mReqIDArray->RemoveRequest(towerDoc, position, upDown);
}

void T2Mover::RemoveCrossEquipID(T2FloorInfo* floorInfo, int position) {
    POINT stopPt = PositionToStopPt(position, ERequestUpDown_0);
    T2Tenant *theFloor = floorInfo->GetFloor(stopPt.y, stopPt.x);

    if (theFloor) {
        RemoveCEID(theFloor->GetEquipID());
        theFloor->RemoveCEID(mEquipID);
    }
}

void T2Mover::RemoveUnstoppable(T2TowerDoc* towerDoc) {
    T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
    BOOL changed = false;

    for (int i = 0; i < mLength; i++) {
        if (IsStopPosition(i) && !theMoverDef->IsaKindOfStopProc(towerDoc, this, i, 0)) {
            RemoveStopBoth(towerDoc, i);
            changed = true;
        }
    }

    if (changed)
        towerDoc->GetTowerMainView()->tmv_vf128(mArea);
}

void T2Mover::AddCrossEquipID(T2FloorInfo* floorInfo, int position) {
    POINT stopPt = PositionToStopPt(position, ERequestUpDown_0);
    T2Tenant *theFloor = floorInfo->GetFloor(stopPt.y, stopPt.x);

    if (theFloor)
        theFloor->AddCEMoverID(floorInfo, stopPt, mEquipID);
    AddCEFloorID(floorInfo, position);
}

void T2Mover::AddCEFloorID(T2FloorInfo* floorInfo, int position) {
    POINT stopPt = PositionToStopPt(position, ERequestUpDown_0);
    unsigned int floorID = floorInfo->GetFloorID(stopPt.y, stopPt.x);

    if (floorID != 0) {
        int i;
        for (i = position - 1; i >= 0; i--) {
            if (IsStopPosition(i))
                break;
        }

        unsigned int idA = 0;
        if (i >= 0)
            floorInfo->GetFloorID(stopPt.y, stopPt.x - (position - i));

        InsertCEID(idA, floorID);
    }
}

void T2Mover::ReplaceID(T2FloorInfo* floorInfo, unsigned int id) {
    floorInfo->UpdateFloorCEArray(mArea, mEquipID, id);
    floorInfo->FillMoverID(mArea, id);
}

POINT T2Mover::PositionToStopPt(int position, ERequestUpDown upDown) {
    POINT result;
    result.x = 0;
    result.y = 0;

    T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
    if (theMoverDef) {
        RECT addSize;
        theMoverDef->GetAddSize(addSize);

        result.y = mArea.bottom - 1 - addSize.bottom - position;
        if (upDown == ERequestUpDown_0)
            result.x = mArea.left;
        else
            result.x = mArea.right;
    }

    return result;
}

int T2Mover::UnitToPosition(int unit) const {
    int result;
    T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
#line 495
    _ASSERT(theMoverDef != NULL);

    RECT addSize;
    theMoverDef->GetAddSize(addSize);
    return mArea.bottom - 1 - addSize.bottom - unit;
}

int T2Mover::PositionToUnit(int position) const {
    int result = mArea.bottom - 1 - position;

    T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
    if (theMoverDef) {
        RECT addSize;
        theMoverDef->GetAddSize(addSize);
        result -= addSize.bottom;
    }

    return result;
}

BOOL T2Mover::IsStopPosition(int position) const {
    BOOL result = false;

    if (position >= 0 && mCEArray && mReqIDArray->IsStopPosition(position))
        result = true;

    return result;
}

BOOL T2Mover::IsStopPosition(int position, ERequestUpDown upDown) {
    BOOL result = false;

    if (position >= 0 && mCEArray && mReqIDArray->GetRequestIDAt(position, upDown))
        result = true;

    return result;
}

BOOL T2Mover::AddModule(T2TowerDoc* towerDoc, int position) {
    BOOL result = false;

    if (GetModuleCount() < mMaxModule && mModuleList) {
        ((T2ElvModuleList *) mModuleList)->AddModule(towerDoc, mLength, position);
        result = true;
    }

    return result;
}

void T2Mover::AddStairModule(T2TowerDoc* towerDoc, const RECT& rect, BOOL insertAtEnd) {
    if (mModuleList)
        ((T2StairModuleList *) mModuleList)->AddModule(towerDoc, rect, insertAtEnd);
}

unsigned int T2Mover::GetRequestID(int position, BOOL isDown) const {
    unsigned int result = 0;

    ERequestUpDown upDown = ERequestUpDown_0;
    if (isDown)
        upDown = ERequestUpDown_1;

    result = mReqIDArray->GetRequestIDAt(position, upDown);
    return result;
}

int T2Mover::GetModuleCount() const {
    int result = 0;

    if (mModuleList)
        result = mModuleList->GetModuleCount();

    return result;
}

BOOL T2Mover::FindStairModule(T2TowerDoc* towerDoc, POINT pt, T2MoverModule*& module1, T2MoverModule*& module2) {
    int var;
    PARTCODE partCode = GetPartFromPoint(towerDoc, pt, &var);
    BOOL result = (partCode == PartCode_2 && var >= 0);

    if (result) {
        if (!mModuleList->FetchItemAt(var, &module1) || !mModuleList->FetchItemAt(var + 1, &module2))
            result = false;
    }

    return result;
}

int T2Mover::CalcModuleRect(const T2MoverModule* module, RECT& rect, int& unk) const {
    return ((T2MoverDef *) GetEquipDef())->CalcModuleRectProc(this, module, rect, unk);
}

T2MoverModule* T2Mover::FindPeople(const T2People* inPeople) const {
    T2MoverModule *result = NULL;
    T2MoverModuleList *theList = GetModuleList();

    if (theList) {
        LArrayIterator moduleIterator(*theList);
        T2MoverModule *moverModule;

        while (!result && moduleIterator.Next(&moverModule)) {
            if (moverModule->IsUsed() && moverModule->mLink1) {
                T2PeopleLinkIterator peopleIterator((T2People *) moverModule->mLink1);
                T2People *people;

                while (peopleIterator.Next(&people)) {
                    if (people == inPeople) {
                        result = moverModule;
                        break;
                    }
                }
            }
        }
    }

    return result;
}

void T2Mover::CalcMachineArea(EEquipPos pos, RECT& rect) const {
    rect = mArea;

#line 672
    _ASSERT(mToolDef != NULL);

    RECT addSize;
    ((T2MoverDef *) mToolDef)->GetAddSize(addSize);

    switch (pos) {
        case EEquipPos_0:
            rect.right = rect.left - addSize.left;
            break;
        case EEquipPos_1:
            rect.left = rect.right - addSize.right;
            break;
        case EEquipPos_2:
            rect.bottom = rect.top - addSize.top;
            break;
        case EEquipPos_3:
            rect.top = rect.bottom - addSize.bottom;
            break;
    }
}

void T2Mover::AdjustLength() {
    CRect rect;
    CalcBodyArea(rect);

    mLength = rect.Height();
}

T2Request* T2Mover::GetRequest(T2FloorInfo* floorInfo, int position, BOOL isDown) const {
    T2Request *result = NULL;

    unsigned int requestID = GetRequestID(position, isDown);
    if (requestID)
        result = floorInfo->GetRequest(requestID);

    return result;
}

int T2Mover::CalcScore(int multiplier) const {
    int result = 0x7FFF;

    if (GetEquipDef()) {
        if (multiplier < 0)
            multiplier *= -1;

        result = ((T2MoverDef *) GetEquipDef())->GetScore() * multiplier;
    }

    return result;
}

int T2Mover::ExpandArea(T2TowerDoc* towerDoc, EEquipPos pos, int count) {
    int result = 0;
    T2FloorInfo *theFloorInfo = towerDoc->towerDoc_vf12C();

    RECT area = mArea;

    RECT addSize;
    ((T2MoverDef *) mToolDef)->GetAddSize(addSize);

    switch (pos) {
        case EEquipPos_2:
            if (count < 0) {
                for (int i = 0; i < -count; i++) {
                    int position = mLength - 1 - i;
                    if (IsStopPosition(position)) {
                        RemoveStopBoth(towerDoc, position);
                        result = 2;
                    }
                }
            }

            mArea.top -= count;
            mLength += count;
            mReqIDArray->Expand(ReqIDArrayPos_1, count);
            ((T2ElvModuleList *) mModuleList)->MoverExpanded(this, EEquipPos_2, count);

            if (count > 0) {
                area.bottom = area.top;
                area.top -= count;
                theFloorInfo->MoverAreaAdded(area, mEquipID);
                area.bottom += -addSize.top;
            } else {
                area.bottom = area.top - count;
                theFloorInfo->MoverAreaRemoved(area);
                area.bottom += -addSize.top + 1;
            }

            if (count > 0) {
                RemoveUnstoppable(towerDoc);
                T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
                for (int i = 0; i < count; i++) {
                    int position = mLength - 1 - i;
                    if (theMoverDef->GetMaxStop() == 0 || GetNumStop() < theMoverDef->GetMaxStop()) {
                        if (theMoverDef->IsaKindOfStopProc(towerDoc, this, position, 1) && !IsStopPosition(position)) {
                            AddStopBoth(towerDoc, position);
                            result = 1;
                        }
                    }
                }
            }

            break;

        case EEquipPos_3:
            if (count < 0) {
                for (int position = 0; position < -count; position++) {
                    if (IsStopPosition(position)) {
                        RemoveStopBoth(towerDoc, position);
                        result = 2;
                    }
                }
            }

            mArea.bottom += count;
            mLength += count;
            mReqIDArray->Expand(ReqIDArrayPos_0, count);
            ((T2ElvModuleList *) mModuleList)->MoverExpanded(this, EEquipPos_3, count);

            if (count > 0) {
                area.top = area.bottom;
                area.bottom += count;
                theFloorInfo->MoverAreaAdded(area, mEquipID);
                area.top -= addSize.bottom;
            } else {
                area.top = area.bottom + count;
                theFloorInfo->MoverAreaRemoved(area);
                area.top -= addSize.bottom + 1;
            }

            if (count > 0) {
                RemoveUnstoppable(towerDoc);
                T2MoverDef *theMoverDef = (T2MoverDef *) GetEquipDef();
                for (int position = 0; position < count; position++) {
                    if (theMoverDef->GetMaxStop() == 0 || GetNumStop() < theMoverDef->GetMaxStop()) {
                        if (theMoverDef->IsaKindOfStopProc(towerDoc, this, position, 1) && !IsStopPosition(position)) {
                            AddStopBoth(towerDoc, position);
                            result = 1;
                        }
                    }
                }
            }

            break;
    }

    if (count != 0)
        towerDoc->GetTowerMainView()->tmv_vf128(area, true);

    return result;
}

BOOL T2Mover::IsHomePosition(int position) const {
    BOOL result = false;

    if (mModuleList)
        result = ((T2ElvModuleList *) mModuleList)->IsHomePosition(position);

    return result;
}

void T2Mover::CalcBodyArea(RECT& rect) const {
    rect = mArea;

    if (GetEquipDef()) {
        RECT addSize;
        ((T2MoverDef *) GetEquipDef())->GetAddSize(addSize);

        rect.top -= addSize.top;
        rect.left -= addSize.left;
        rect.bottom -= addSize.bottom;
        rect.right -= addSize.right;
    }
}

int T2Mover::CalcModulePos(T2MoverModule* module, ERequestUpDown upDown) {
    return ((T2MoverDef *) GetEquipDef())->CalcModulePosProc(this, module, upDown);
}

void T2Mover::ShowShaft() {
    if (!mShowShaft) {
        mShowShaft = true;

        T2TowerDoc *theTowerDoc = GetCurrentT2TowerDoc();
        theTowerDoc->GetTowerMainView()->tmv_vf128(mArea);
    }
}

void T2Mover::HideShaft() {
    if (mShowShaft) {
        mShowShaft = false;

        T2TowerDoc *theTowerDoc = GetCurrentT2TowerDoc();
        theTowerDoc->GetTowerMainView()->tmv_vf128(mArea);
        theTowerDoc->towerDoc_vf12C()->SetTenantDrawModeByRect(mArea, DrawMode2);
    }
}

/*virtual*/ unsigned int T2Mover::Idle(T2TowerDoc* towerDoc) {
    unsigned int result = 0xFFFFFFFF;
    result = ((T2MoverDef *) GetEquipDef())->IdleProc(this, towerDoc);
    return result;
}

/*virtual*/ void T2Mover::LoadSelf(T2Archive& archive, T2TowerDoc* towerDoc) {
    DWORD code;
    archive >> code;
#line 1193
    _ASSERT(code == '<MV>');

    T2Equip::LoadSelf(archive, towerDoc);

    if (IsUsed()) {
        mToolDef = towerDoc->mMoverTemplates->FindMoverDef(mEquipType);
        if (mToolDef) {
            mAttribute = mToolDef->GetAttribute();
            mCapacity = GetEquipDef()->GetCapacity();
        }

        unsigned char uc;
        short s;

        archive >> uc;
        mShowShaft = (uc != 0);

        mCheckRequest = true;

        archive >> s;
        mLength = s;

        mReqIDArray = T2RequestIDArray::ReadReqIDArray(archive);

        archive >> s;
        mWaitCount = s;
        archive >> s;
        mMaxModule = s;

        mModuleList = T2MoverModuleList::ReadMMList(archive, towerDoc);

        archive >> mRefCon;

        if (GetEquipDef()) {
            GetEquipDef()->LoadExtraData(archive, towerDoc, this);
        } else {
            int count;
            archive >> count;

            for (int i = 0; i < count; i++) {
                unsigned char tmp;
                archive >> tmp;
            }
        }
    }
}

/*virtual*/ void T2Mover::SaveSelf(T2Archive& archive) {
    DWORD code = '<MV>';
    archive << code;

    T2Equip::SaveSelf(archive);

    if (IsUsed()) {
        unsigned char uc;
        uc = mShowShaft ? 1 : 0;
        archive << uc;

        archive << (short) mLength;
        T2RequestIDArray::WriteReqIDArray(mReqIDArray, archive);
        archive << (short) mWaitCount;
        archive << (short) mMaxModule;
        T2MoverModuleList::WriteMMList(mModuleList, archive);
        archive << mRefCon;

        GetEquipDef()->SaveExtraData(archive, this);
    }
}

/*virtual*/ T2InfoDialog* T2Mover::ShowInfoDialog(T2TowerDoc* towerDoc, CPoint pt) {
    return ((T2MoverDef *) GetEquipDef())->ShowInfoDialog(towerDoc, this, pt);
}