#include "global.h"
#include "berry.h"
#include "battle_tower.h"
#include "easy_chat.h"
#include "event_data.h"
#include "mail.h"
#include "mystery_event_script.h"
#include "pokedex.h"
#include "pokemon.h"
#include "pokemon_size_record.h"
#include "script.h"
#include "strings.h"
#include "string_util.h"
#include "text.h"
#include "util.h"
#include "mystery_event_msg.h"
#include "pokemon_storage_system.h"

extern ScrCmdFunc gMysteryEventScriptCmdTable[];
extern ScrCmdFunc gMysteryEventScriptCmdTableEnd[];

#define LANGUAGE_MASK 0x1
#define VERSION_MASK 0x200

#define mScriptBase data[0]
#define mOffset data[1]
#define mStatus data[2]
#define mValid data[3]

EWRAM_DATA static struct ScriptContext sMysteryEventScriptContext = {0};

static bool32 CheckCompatibility(u16 a1, u32 a2, u16 a3, u32 a4)
{
    if (!(a1 & LANGUAGE_MASK))
        return FALSE;

    if (!(a2 & LANGUAGE_MASK))
        return FALSE;

    if (!(a3 & 0x4))
        return FALSE;

    if (!(a4 & VERSION_MASK))
        return FALSE;

    return TRUE;
}

static void SetIncompatible(void)
{
    StringExpandPlaceholders(gStringVar4, gText_MysteryEventCantBeUsed);
    SetMysteryEventScriptStatus(MEVENT_STATUS_FAILURE);
}

static void InitMysteryEventScript(struct ScriptContext *ctx, u8 *script)
{
    InitScriptContext(ctx, gMysteryEventScriptCmdTable, gMysteryEventScriptCmdTableEnd);
    SetupBytecodeScript(ctx, script);
    ctx->mScriptBase = (u32)script;
    ctx->mOffset = 0;
    ctx->mStatus = MEVENT_STATUS_LOAD_OK;
    ctx->mValid = FALSE;
}

static bool32 RunMysteryEventScriptCommand(struct ScriptContext *ctx)
{
    if (RunScriptCommand(ctx) && ctx->mValid)
        return TRUE;
    else
        return FALSE;
}

void InitMysteryEventScriptContext(u8 *script)
{
    InitMysteryEventScript(&sMysteryEventScriptContext, script);
}

bool32 RunMysteryEventScriptContextCommand(u32 *status)
{
    bool32 ret = RunMysteryEventScriptCommand(&sMysteryEventScriptContext);
    *status = sMysteryEventScriptContext.mStatus;

    return ret;
}

u32 RunMysteryEventScript(u8 *script)
{
    struct ScriptContext *ctx = &sMysteryEventScriptContext;
    InitMysteryEventScript(ctx, script);
    while (RunMysteryEventScriptCommand(ctx));

    return ctx->mStatus;
}

void SetMysteryEventScriptStatus(u32 status)
{
    sMysteryEventScriptContext.mStatus = status;
}

static int CalcRecordMixingGiftChecksum(void)
{
    unsigned int i;
    int sum = 0;
    u8 *data = (u8*)(&gSaveBlock1Ptr->recordMixingGift.data);

    for (i = 0; i < sizeof(gSaveBlock1Ptr->recordMixingGift.data); i++)
        sum += data[i];

    return sum;
}

static bool32 IsRecordMixingGiftValid(void)
{
    struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data;
    int checksum = CalcRecordMixingGiftChecksum();

    if (data->unk0 == 0
        || data->quantity == 0
        || data->itemId == 0
        || checksum == 0
        || checksum != gSaveBlock1Ptr->recordMixingGift.checksum)
        return FALSE;
    else
        return TRUE;
}

static void ClearRecordMixingGift(void)
{
    CpuFill16(0, &gSaveBlock1Ptr->recordMixingGift, sizeof(gSaveBlock1Ptr->recordMixingGift));
}

static void SetRecordMixingGift(u8 unk, u8 quantity, u16 itemId)
{
    if (!unk || !quantity || !itemId)
    {
        ClearRecordMixingGift();
    }
    else
    {
        gSaveBlock1Ptr->recordMixingGift.data.unk0 = unk;
        gSaveBlock1Ptr->recordMixingGift.data.quantity = quantity;
        gSaveBlock1Ptr->recordMixingGift.data.itemId = itemId;
        gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum();
    }
}

u16 GetRecordMixingGift(void)
{
    struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data;

    if (!IsRecordMixingGiftValid())
    {
        ClearRecordMixingGift();
        return 0;
    }
    else
    {
        u16 itemId = data->itemId;
        data->quantity--;
        if (data->quantity == 0)
            ClearRecordMixingGift();
        else
            gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum();

        return itemId;
    }
}

bool8 MEScrCmd_end(struct ScriptContext *ctx)
{
    StopScript(ctx);
    return TRUE;
}

bool8 MEScrCmd_checkcompat(struct ScriptContext *ctx)
{
    u16 v1;
    u32 v2;
    u16 v3;
    u32 v4;

    ctx->mOffset = ScriptReadWord(ctx);
    v1 = ScriptReadHalfword(ctx);
    v2 = ScriptReadWord(ctx);
    v3 = ScriptReadHalfword(ctx);
    v4 = ScriptReadWord(ctx);

    if (CheckCompatibility(v1, v2, v3, v4) == TRUE)
        ctx->mValid = TRUE;
    else
        SetIncompatible();

    return TRUE;
}

bool8 MEScrCmd_nop(struct ScriptContext *ctx)
{
    return FALSE;
}

bool8 MEScrCmd_setstatus(struct ScriptContext *ctx)
{
    u8 status = ScriptReadByte(ctx);
    ctx->mStatus = status;
    return FALSE;
}

bool8 MEScrCmd_setmsg(struct ScriptContext *ctx)
{
    u8 status = ScriptReadByte(ctx);
    u8 *str = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    if (status == MEVENT_STATUS_FF || status == ctx->mStatus)
        StringExpandPlaceholders(gStringVar4, str);
    return FALSE;
}

bool8 MEScrCmd_runscript(struct ScriptContext *ctx)
{
    u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    ScriptContext2_RunNewScript(script);
    return FALSE;
}

bool8 MEScrCmd_setenigmaberry(struct ScriptContext *ctx)
{
    u8 *str;
    const u8 *message;
    bool32 haveBerry = IsEnigmaBerryValid();
    u8 *berry = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    StringCopyN(gStringVar1, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_LENGTH + 1);
    SetEnigmaBerry(berry);
    StringCopyN(gStringVar2, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_LENGTH + 1);

    if (!haveBerry)
    {
        str = gStringVar4;
        message = gText_MysteryEventBerry;
    }
    else if (StringCompare(gStringVar1, gStringVar2))
    {
        str = gStringVar4;
        message = gText_MysteryEventBerryTransform;
    }
    else
    {
        str = gStringVar4;
        message = gText_MysteryEventBerryObtained;
    }

    StringExpandPlaceholders(str, message);

    ctx->mStatus = MEVENT_STATUS_SUCCESS;

    if (IsEnigmaBerryValid() == TRUE)
        VarSet(VAR_ENIGMA_BERRY_AVAILABLE, 1);
    else
        ctx->mStatus = MEVENT_STATUS_LOAD_ERROR;

    return FALSE;
}

bool8 MEScrCmd_giveribbon(struct ScriptContext *ctx)
{
    u8 index = ScriptReadByte(ctx);
    u8 ribbonId = ScriptReadByte(ctx);
    GiveGiftRibbonToParty(index, ribbonId);
    StringExpandPlaceholders(gStringVar4, gText_MysteryEventSpecialRibbon);
    ctx->mStatus = MEVENT_STATUS_SUCCESS;
    return FALSE;
}

bool8 MEScrCmd_initramscript(struct ScriptContext *ctx)
{
    u8 mapGroup = ScriptReadByte(ctx);
    u8 mapNum = ScriptReadByte(ctx);
    u8 objectId = ScriptReadByte(ctx);
    u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    u8 *scriptEnd = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    InitRamScript(script, scriptEnd - script, mapGroup, mapNum, objectId);
    return FALSE;
}

bool8 MEScrCmd_givenationaldex(struct ScriptContext *ctx)
{
    EnableNationalPokedex();
    StringExpandPlaceholders(gStringVar4, gText_MysteryEventNationalDex);
    ctx->mStatus = MEVENT_STATUS_SUCCESS;
    return FALSE;
}

bool8 MEScrCmd_addrareword(struct ScriptContext *ctx)
{
    UnlockAdditionalPhrase(ScriptReadByte(ctx));
    StringExpandPlaceholders(gStringVar4, gText_MysteryEventRareWord);
    ctx->mStatus = MEVENT_STATUS_SUCCESS;
    return FALSE;
}

bool8 MEScrCmd_setrecordmixinggift(struct ScriptContext *ctx)
{
    u8 unk = ScriptReadByte(ctx);
    u8 quantity = ScriptReadByte(ctx);
    u16 itemId = ScriptReadHalfword(ctx);
    SetRecordMixingGift(unk, quantity, itemId);
    return FALSE;
}

bool8 MEScrCmd_givepokemon(struct ScriptContext *ctx)
{
    struct Mail mail;
    struct Pokemon pokemon;
    u16 species;
    u16 heldItem;
    u32 data = ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase;
    void *pokemonPtr = (void *)data;
    void *mailPtr = (void *)(data + sizeof(struct Pokemon));

    pokemon = *(struct Pokemon *)pokemonPtr;
    species = GetMonData(&pokemon, MON_DATA_SPECIES2);

    if (species == SPECIES_EGG)
        StringCopyN(gStringVar1, gText_EggNickname, POKEMON_NAME_LENGTH + 1);
    else
        StringCopyN(gStringVar1, gText_Pokemon, POKEMON_NAME_LENGTH + 1);

    if (gPlayerPartyCount == PARTY_SIZE)
    {
        StringExpandPlaceholders(gStringVar4, gText_MysteryEventFullParty);
        ctx->mStatus = MEVENT_STATUS_FAILURE;
    }
    else
    {
        memcpy(&gPlayerParty[PARTY_SIZE - 1], pokemonPtr, sizeof(struct Pokemon));
        memcpy(&mail, mailPtr, sizeof(struct Mail));

        if (species != SPECIES_EGG)
        {
            u16 pokedexNum = SpeciesToNationalPokedexNum(species);
            GetSetPokedexFlag(pokedexNum, FLAG_SET_SEEN);
            GetSetPokedexFlag(pokedexNum, FLAG_SET_CAUGHT);
        }

        heldItem = GetMonData(&gPlayerParty[PARTY_SIZE - 1], MON_DATA_HELD_ITEM);
        if (ItemIsMail(heldItem))
            GiveMailToMon(&gPlayerParty[PARTY_SIZE - 1], &mail);
        CompactPartySlots();
        CalculatePlayerPartyCount();
        StringExpandPlaceholders(gStringVar4, gText_MysteryEventSentOver);
        ctx->mStatus = MEVENT_STATUS_SUCCESS;
    }

    return FALSE;
}

bool8 MEScrCmd_addtrainer(struct ScriptContext *ctx)
{
    u32 data = ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase;
    memcpy(&gSaveBlock2Ptr->frontier.ereaderTrainer, (void *)data, sizeof(gSaveBlock2Ptr->frontier.ereaderTrainer));
    ValidateEReaderTrainer();
    StringExpandPlaceholders(gStringVar4, gText_MysteryEventNewTrainer);
    ctx->mStatus = MEVENT_STATUS_SUCCESS;
    return FALSE;
}

bool8 MEScrCmd_enableresetrtc(struct ScriptContext *ctx)
{
    EnableResetRTC();
    StringExpandPlaceholders(gStringVar4, gText_InGameClockUsable);
    ctx->mStatus = MEVENT_STATUS_SUCCESS;
    return FALSE;
}

bool8 MEScrCmd_checksum(struct ScriptContext *ctx)
{
    int checksum = ScriptReadWord(ctx);
    u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    if (checksum != CalcByteArraySum(data, dataEnd - data))
    {
        ctx->mValid = FALSE;
        ctx->mStatus = MEVENT_STATUS_LOAD_ERROR;
    }
    return TRUE;
}

bool8 MEScrCmd_crc(struct ScriptContext *ctx)
{
    int crc = ScriptReadWord(ctx);
    u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->mOffset + ctx->mScriptBase);
    if (crc != CalcCRC16(data, dataEnd - data))
    {
        ctx->mValid = FALSE;
        ctx->mStatus = MEVENT_STATUS_LOAD_ERROR;
    }
    return TRUE;
}