/** @file /world/rules.cpp 

    Implementace hlavickoveho souboru /world/rules.h

    @author Petr Wolf
*/

#include "common/rm/rmmap.h" 
#include "common/rm/rmbuildingi.h"
#include "common/rm/rmadvxmli.h"
#include "common/rm/rmxmli.h"
#include "common/da.h"
#include "world/rules.h"
#include "world/world_messages.h"
#include "ai/PathFind/pathenv.h"
#include "ai/Diplomacy/diptypes.h"

using namespace World;   
using namespace rm;
using namespace ai_ns::pathfind_ns;
using namespace ai_ns::diplomacy_ns;

TRules::TRules()
{

}

TRules::~TRules()
{

}

int TRules::init()
{
    int i;
    DA<int> ids;

    // nacteni typu budov
    // ==================
    try {
        TRM_building_i * rmbuilding;
        
        if (!(rmbuilding = (TRM_building_i*)KSend(MSG_GET_RM_BUILDING_I, 0)))
            THROW(E_8K, "Failed to query rmbuilding interface\n");

        // odeslani pozadavku na nacteni budov
        rmbuilding->getIds(&ids);
        for (i = ids.getNext(-1); i!=-1; i=ids.getNext(i))
            rmbuilding->request(i);

        // nacteni bufferu
        rmbuilding->loadBuffer();

        // nacteni jednotlivych typu budov
        DA<BUILDING *> * _building_types;
        rmbuilding->getBuildings(&_building_types);
        for (i = _building_types->getNext(-1); i != -1; i = _building_types->getNext(i)) {    
            building_types[i] = new TBuilding(_building_types->operator[](i));
        }

        // uklid
        delete rmbuilding;
    }
    catch (E_8K_RM &e) {
        // nepodarilo se nacist zdroje - hra nemuze pokracovat
        // TODO co ted?
        throw e;
    }

    // nacteni typu jednotek
    // =====================
    try {
        TRM_advxml_i<UNIT> * rmunit;

        if(!(rmunit = (TRM_advxml_i<UNIT> * )KSend(MSG_GET_RM_UNIT_I, 0)))
            THROW(E_8K, "Failed to query rmunit interface\n");

        //requestuj vsechny jednotky
        rmunit->getIds(&ids);
        for (i = ids.getNext(-1); i != -1; i = ids.getNext(i))
            rmunit->request(i);
        
        // nacteni bufferu
        rmunit->loadBuffer();

        // nacteni jednotlivych typu jednotek
        DA<UNIT *> * _unit_types;
        rmunit->getAll(&_unit_types);

        for (i = _unit_types->getNext(-1); i != -1; i = _unit_types->getNext(i)) {
            unit_types[i] = new TUnit(_unit_types->operator[](i));
        }

        // uklid
        delete rmunit;
    }
    catch (E_8K_RM &e) {
        // nepodarilo se nacist zdroje - hra nemuze pokracovat
        // TODO co ted?
        throw e;
    }
    
    // nacteni typu terenu, skriptu
    // ============================
    try {
        TRM_xml_i<void> * rmxml;
        if(!(rmxml = (TRM_xml_i<void> *)KSend(MSG_GET_RM_XML_I, (void *)STRUCT_TERRAIN)))
            THROW(E_8K, "Failed to query rmxml interface\n");
        
        // requestuji vsechny tereny
        for (i = 1; i <= TERRAIN_TYPES_COUNT; i++)
            rmxml->request(i);
        
        // requestuji vsechny skripty
        for (i = TCL_SCRIPT_MIN_ID; i <= TCL_SCRIPT_MAX_ID; i++)
            rmxml->request(i);
        
        // nacteni bufferu
        rmxml->loadBuffer();

        // pole pro nacteni dat
        DA<VOID *> * _data;
        rmxml->getAll(&_data);

        // nacteni jednotlivych typu terenu
        for (i = 1; i <= TERRAIN_TYPES_COUNT; i++) {
            terrain_types[i] = new TTerrain((TERRAIN *)(*_data)[i]);
        }
        
        // nacteni jednotlivych skriptu
        for (i = TCL_SCRIPT_MIN_ID; i <= TCL_SCRIPT_MAX_ID; i++) {
            scripts[i] = (TCL_SCRIPT *)(*_data)[i];
        }

        // uklid
        delete rmxml;
    }
    catch (E_8K_RM &e) {
        // nepodarilo se nacist zdroje - hra nemuze pokracovat
        // TODO co ted?
        throw e;
    }

    // nacteni bonusu
    // ==============
    try {
        TRM_advxml_i<UNIT_PROPERTY_BONUS> * RMbi = (TRM_advxml_i<UNIT_PROPERTY_BONUS> *)KSend(MSG_GET_RM_BONUS_I, 0);
        
        // requestuji vsechny bonusy
        for (i = BONUS_MIN_ID; i <= BONUS_MAX_ID; i++)
            RMbi->request(i);

        // nacteni bufferu
        RMbi->loadBuffer();

        // nacteni jednotlivych typu bonusu
        DA<UNIT_PROPERTY_BONUS *> * _bonus_types;
        RMbi->getAll(&_bonus_types);

        for (i = _bonus_types->getNext(-1); i != -1; i = _bonus_types->getNext(i)) {
            bonus_types[i] = new TBonus((*_bonus_types)[i]);
        }

        // uklid
        delete RMbi;
    }
    catch (E_8K_RM &e) {
        // nepodarilo se nacist zdroje - hra nemuze pokracovat
        // TODO co ted?
        throw e; 
    }

    return 0;
}

int TRules::reload()
{
    int i;

    // nacteni typu terenu, skriptu a bonusu
    // =====================================
    try {
        TRM_xml_i<void> * rmxml;
        if(!(rmxml = (TRM_xml_i<void> *)KSend(MSG_GET_RM_XML_I, (void *)STRUCT_TCL)))
            THROW(E_8K, "Failed to query rmxml interface\n");
        
        // uvolnim vsechny skripty
        /*
        for (i = TCL_SCRIPT_MIN_ID; i <= TCL_SCRIPT_MAX_ID; i++)
            rmxml->freeData(i);
        */

        // requestuji vsechny skripty
        for (i = TCL_SCRIPT_MIN_ID; i <= TCL_SCRIPT_MAX_ID; i++)
            rmxml->request(i);
     
        // nacteni bufferu
        rmxml->loadBuffer();

        // pole pro nacteni dat
        DA<VOID *> * _data;
        rmxml->getAll(&_data);
        
        // nacteni jednotlivych skriptu
        for (i = TCL_SCRIPT_MIN_ID; i <= TCL_SCRIPT_MAX_ID; i++) {
            scripts[i] = (TCL_SCRIPT *)_data->operator[](i);
        }

        // uklid
        delete rmxml;
    }
    catch (E_8K_RM &e) {
        // nepodarilo se nacist zdroje - hra nemuze pokracovat
        // TODO co ted?
        throw e; 
    }

    return 0;
}

int TRules::shutdown()
{
    // TODO co tady s XML daty?

    return 0;
}

void TRules::writeToTCL(TTCL_Interpreter & interpreter)
{
    // zapis budov
    building_types.writeToTCL(interpreter, "building_types");

    // zapis jednotek
    unit_types.writeToTCL(interpreter, "unit_types");

    // zapis typu terenu
    terrain_types.writeToTCL(interpreter, "terrain_types");    

    // zapis bonusu
    bonus_types.writeToTCL(interpreter, "bonus_types");

    // zapis konstant a predmetu zprav do prostredi TCL interpretu
    // ===========================================================
    int i;

    // celociselne konstanty
    TCL_CONST consts[] = {
        {"TT_PLAIN", TT_PLAIN},
        {"TT_FOREST", TT_FOREST},
        {"TT_DEEP_FOREST", TT_DEEP_FOREST},
        {"TT_ROCKS", TT_ROCKS},
        {"TT_SWAMP", TT_SWAMP},
        {"TT_RIVER", TT_RIVER},
        {"TT_SEA", TT_SEA},
        {"TT_SHALLOW", TT_SHALLOW},
        {"TT_TOWN", TT_TOWN},
        {"CP_SAME_HEX", CP_SAME_HEX},
        {"CP_ADJACENT_HEX", CP_ADJACENT_HEX},
        {"ST_COVERED", ST_COVERED},
        {"ST_OPEN", ST_OPEN},
        {"WS_SUNNY", WS_SUNNY},
        {"WS_RAIN", WS_RAIN},
        {"WS_SNOW", WS_SNOW},
        {"ER_DRAW", ER_DRAW},
        {"ER_VICTORY_DESTROY", ER_VICTORY_DESTROY},
        {"ER_VICTORY_CONQUER", ER_VICTORY_CONQUER},
        {"ER_VICTORY_TIMEOUT", ER_VICTORY_TIMEOUT},
        {"MSG_GET_HEX", MSG_GET_HEX},
        {"MSG_GET_LIVING_UNIT", MSG_GET_LIVING_UNIT},
        {"MSG_GET_LIVING_BUILDING", MSG_GET_LIVING_BUILDING},
        {"MSG_GET_HEX_BY_ID", MSG_GET_HEX_BY_ID},
        {"MSG_GET_PLAYER", MSG_GET_PLAYER},
        {"MSG_GET_PLAYERS", MSG_GET_PLAYERS},
        {"MSG_GET_LIVING_UNITS", MSG_GET_LIVING_UNITS},
        {"MSG_GET_LIVING_BUILDINGS", MSG_GET_LIVING_BUILDINGS},
        {"MSG_GET_TOWN", MSG_GET_TOWN},
        {"MSG_GET_TOWNS", MSG_GET_TOWNS},
        {"MSG_GET_KINGDOM", MSG_GET_KINGDOM},
        {"MSG_GET_KINGDOMS", MSG_GET_KINGDOMS},
        {"MSG_GET_WEATHER", MSG_GET_WEATHER},
        {"MSG_GET_HEX_NEIGHBOUR", MSG_GET_HEX_NEIGHBOUR},
        {"MSG_GET_HEX_NEIGHBOURS", MSG_GET_HEX_NEIGHBOURS},
        {"UT_INFANTRY", UT_INFANTRY},
        {"UT_CAVALRY", UT_CAVALRY},
        {"UT_VEHICLE", UT_VEHICLE},
        {"UT_INDIVIDUAL", UT_INDIVIDUAL},
        {"UT_BEAST", UT_BEAST},
        {"UT_FLYING", UT_FLYING},
        {"MFC_ANYTHING", MFC_ANYTHING},
        {"MFC_MOVEMENT_FIRST", MFC_MOVEMENT_FIRST},
        {"MFC_ATTACK_FIRST", MFC_ATTACK_FIRST},
        {"MFC_SINGLE", MFC_SINGLE},  
        {"FT_NONE", FT_NONE},
        {"FT_FACE_TO_FACE", FT_FACE_TO_FACE},
        {"FT_BLAST", FT_BLAST},
        {"FT_FIRE", FT_FIRE},
        {"FT_MAGIC", FT_MAGIC},
        {"FT_CATAPULT", FT_CATAPULT},
        {"UP_ATTACK", UP_ATTACK},
        {"UP_DEFENSE", UP_DEFENSE},
        {"UP_LIVES", UP_LIVES},
        {"UP_MOVEMENT", UP_MOVEMENT},
        {"UP_ATTACK_RANGE", UP_ATTACK_RANGE},
        {"US_IDLE", US_IDLE},
        {"US_BUILDING", US_BUILDING},
        {"US_HAS_STARTED_BUILDING", US_HAS_STARTED_BUILDING},
        {"US_HAS_MOVED", US_HAS_MOVED},
        {"US_HAS_FOUGHT", US_HAS_FOUGHT},
        {"US_HAS_FOUGHT_AND_MOVED", US_HAS_FOUGHT_AND_MOVED},
        {"US_EXHAUSTED", US_EXHAUSTED},
        {"UW_OK", UW_OK},
        {"UW_KO", UW_KO},
        {"RELATIONSHIP_WAR", RELATIONSHIP_WAR},
        {"RELATIONSHIP_ENEMY", RELATIONSHIP_ENEMY},
        {"RELATIONSHIP_TRUCE", RELATIONSHIP_TRUCE},
        {"RELATIONSHIP_ALLY", RELATIONSHIP_ALLY},
        {"MAX_UNIT_LEVEL", MAX_UNIT_LEVEL},
        {"EXPERIENCE_LEVEL", EXPERIENCE_LEVEL},
        {"CONQUER_TOWN_COUNT", CONQUER_TOWN_COUNT},
        {"CONQUER_KINGDOM_COUNT", CONQUER_KINGDOM_COUNT},
        {"MIN_PLAYER_INCOME", MIN_PLAYER_INCOME},
        {"TOWN_INCOME", TOWN_INCOME},
        {"KINGDOM_INCOME", KINGDOM_INCOME},
        {"EGC_CONQUER", EGC_CONQUER},
        {"EGC_DEATHMATCH", EGC_DEATHMATCH},
#ifdef _DEBUG
        {"DBG", 1},
#else
        {"DBG", 0},
#endif
        {"UnitsNotTransparent", GCT_UnitsNotTransparent},
        {"IgnoreMyUnits", GCT_IgnoreMyUnits},
        {"IgnoreAllUnits", GCT_IgnoreAllUnits},
        {"IgnoreRivers", GCT_IgnoreRivers},
        {"SampleUnit", GCT_SampleUnit},
        {"ERR_InvalidCoords", ERR_InvalidCoords},
        {"ERR_InvalidHexId", ERR_InvalidHexId},
        {"ERR_InvalidUnitId", ERR_InvalidUnitId},
        {"ERR_InvalidBuildingId", ERR_InvalidBuildingId},
        {"ERR_WorldNotInitialized", ERR_WorldNotInitialized},
        {"ERR_InvalidInput", ERR_InvalidInput},
        {"ERR_NotEnoughMoney", ERR_NotEnoughMoney},
        {NULL, 0}
    };

    for (i = 0; consts[i].name != NULL; i++) {
        interpreter.setConstInt(consts[i].name, consts[i].value);
    }

    // Desetinne konstanty
    TCL_DOUBLE_CONST double_consts[] = {
        {"CONQUER_TOWN_RATIO", CONQUER_TOWN_RATIO},
        {"CONQUER_KINGDOM_RATIO", CONQUER_KINGDOM_RATIO},
        {"ATTACK_BONUS_TOWN", ATTACK_BONUS_TOWN},
        {"DEFENSE_BONUS_TOWN", DEFENSE_BONUS_TOWN}, 
        {NULL, 0}
    };

    for (i = 0; double_consts[i].name != NULL; i++) {
        interpreter.setConstDouble(double_consts[i].name, double_consts[i].value);
    }
}