#include "StdAfx.h"
#include "T2Archive.h"
#include "T2Tenant.h"
#include "T2TenantArray.h"
#include "T2TenantArrayList.h"

T2TenantArrayList::T2TenantArrayList() {
    mCounter = 0;
    T2TenantArray *tenantArray = new T2TenantArray;
    Add(tenantArray);
}

/*virtual*/ T2TenantArrayList::~T2TenantArrayList() {
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        delete tenantArray;
}

void T2TenantArrayList::Add(T2TenantArray* tenantArray) {
    InsertItemsAt(1, mItemCount + 1, &tenantArray);
}

unsigned int T2TenantArrayList::GetItemCount() {
    return GetCount();
}

T2TenantArray* T2TenantArrayList::GetItemAt(int index) {
    T2TenantArray *tenantArray = NULL;
    FetchItemAt(index, &tenantArray);
    return tenantArray;
}

T2Tenant* T2TenantArrayList::GetTenantByID(unsigned int tenantID) {
    if (tenantID == 0)
        return NULL;

    int group = (tenantID - 1000) / T2TenantArray::kGroupSize;
    int indexInGroup = (tenantID - 1000) % T2TenantArray::kGroupSize;
    T2TenantArray *tenantArray = GetItemAt(group + 1);
    if (tenantArray)
        return tenantArray->GetIndexTenant(indexInGroup);
    else
        return NULL;
}

T2Tenant* T2TenantArrayList::GetTenantByPID(DWORD pluginID) {
    T2Tenant *tenant = NULL;
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (!tenant && iterator.Next(&tenantArray)) {
        tenant = tenantArray->GetTenantByPID(pluginID);
    }

    return tenant;
}

T2Tenant* T2TenantArrayList::FindUnusedTenant() {
    T2Tenant *theUnusedTenant = NULL;
    LArrayIterator iterator(*this);
    T2TenantArray *theTenantArray = NULL;

    while (!theUnusedTenant && iterator.Next(&theTenantArray)) {
        theUnusedTenant = theTenantArray->FindUnusedTenant();
    }

    if (!theUnusedTenant) {
        unsigned int newStartID = 1000;
        if (theTenantArray)
            newStartID = theTenantArray->GetStartID() + T2TenantArray::kGroupSize;

        theTenantArray = new T2TenantArray(newStartID);
        if (theTenantArray) {
            Add(theTenantArray);
            theUnusedTenant = theTenantArray->FindUnusedTenant();
        }
    }

    return theUnusedTenant;
}

void T2TenantArrayList::DispatchIdle(T2TowerDoc* towerDoc) {
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        tenantArray->DispatchIdle(towerDoc, mCounter);

    mCounter++;
    if (mCounter >= 32)
        mCounter = 0;
}

void T2TenantArrayList::TenantRemoved(unsigned int v) {
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        tenantArray->TenantRemoved(v);
}

void T2TenantArrayList::BreakoutEmergency(T2TowerDoc* towerDoc) {
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        tenantArray->BreakoutEmergency(towerDoc);
}

int T2TenantArrayList::CalcMentenanceCost(T2TowerDoc* towerDoc) const {
    int theCost = 0;
    LArrayIterator iterator(*this);
    T2TenantArray *theTenantArray;

    while (iterator.Next(&theTenantArray))
        theCost += theTenantArray->CalcMentenanceCost(towerDoc);

    return theCost;
}

LArray* T2TenantArrayList::MakeTenantList(int type) {
    LArray *result = new LArray(sizeof(T2Tenant *));

    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray)) {
        for (int i = 0; i < T2TenantArray::kGroupSize; i++) {
            T2Tenant *tenant = &tenantArray->mTenants[i];
            if (tenant->IsUsed() && tenant->GetEquipType() == type)
                result->Add(&tenant);
        }
    }

    if (result->GetCount() > 0) {
        return result;
    } else {
        delete result;
        return NULL;
    }
}

LArray* T2TenantArrayList::MakeTenantList(BOOL(*func) (const T2Tenant*)) {
    LArray *result = new LArray(sizeof(T2Tenant *));

    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray)) {
        for (int i = 0; i < T2TenantArray::kGroupSize; i++) {
            T2Tenant *tenant = &tenantArray->mTenants[i];
            if (tenant->IsUsed() && func(tenant))
                result->Add(&tenant);
        }
    }

    if (result->GetCount() > 0) {
        return result;
    } else {
        delete result;
        return NULL;
    }
}

void T2TenantArrayList::Read(T2Archive& archive, T2TowerDoc* towerDoc) {
    archive >> mCounter;

    int count;
    archive >> count;

    RemoveItemsAt(GetCount(), 1);
    unsigned int startID = 1000;

    for (int i = 0; i < count; i++) {
        Add(new T2TenantArray(startID));
        startID += T2TenantArray::kGroupSize;
    }

    LArrayIterator iter(*this);
    T2TenantArray *theTenantArray;

    while (iter.Next(&theTenantArray))
        theTenantArray->Read(archive, towerDoc);
}

void T2TenantArrayList::Write(T2Archive& archive) {
    archive << mCounter;

    int count = GetItemCount();
    archive << count;

    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        tenantArray->Write(archive);
}

void T2TenantArrayList::RecoverRelatedTenantList(T2RegistedTenantDB* db) {
    LArrayIterator iterator(*this);
    T2TenantArray *tenantArray;

    while (iterator.Next(&tenantArray))
        tenantArray->RecoverRelatedTenantList(db);
}