#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "decode.h"
#include "emulator.h"

// Retrieve the bits between positions 'lsb' (inclusive) and 'msb' (exclusive) from a given word 
// as a new zero-extended word.
static word getBits(word wrd, uint8_t lsb, uint8_t msb) {

    // Ensure LSB and MSB are within range of word size, and in the correct order
    assert(lsb < msb && msb <= WORD_BITS);

    wrd &= ((dword) 1 << msb) - 1;
    return wrd >> lsb;
}

// Given a binary word, return its internal representation as an a64instruction struct encoding the same
// information.
a64inst_instruction *decode(word wrd) {

    a64inst_instruction *inst = malloc(sizeof(a64inst_instruction));
    if (inst == NULL) {
        fprintf(stderr, "Ran out of memory while attempting to decode an instruction!\n");
        exit(1);
    }

    word typeId = getBits(wrd, TYPE_ID_LSB, TYPE_ID_MSB);
    // Halt interpretation
    if (wrd == HALT_WORD) {
        inst->type = a64inst_HALT;

    // Data Processing Immediate interpretation
    } else if (typeId == DP_IMM_ID) {
        inst->type = a64inst_DPIMMEDIATE;
        inst->data.DPImmediateData.regType = getBits(wrd, DP_WIDTH_LSB, DP_WIDTH_MSB);
        inst->data.DPImmediateData.processOp = getBits(wrd, DP_OP_LSB, DP_OP_MSB);
        inst->data.DPImmediateData.dest = getBits(wrd, DP_DEST_LSB, DP_DEST_MSB);

        switch(getBits(wrd, DP_IMM_OPTYPE_LSB, DP_IMM_OPTYPE_MSB)) {

            case DP_IMM_OPTYPE_ARITHM:
                inst->data.DPImmediateData.DPIOpType = a64inst_DPI_ARITHM;
                inst->data.DPImmediateData.processOpData.arithmData.shiftImmediate = getBits(wrd, DP_IMM_ARITHM_SHIFTFLAG_LSB, DP_IMM_ARITHM_SHIFTFLAG_MSB);
                inst->data.DPImmediateData.processOpData.arithmData.immediate = getBits(wrd, DP_IMM_ARITHM_IMMVAL_LSB, DP_IMM_ARITHM_IMMVAL_MSB);
                inst->data.DPImmediateData.processOpData.arithmData.src = getBits(wrd, DP_IMM_ARITHM_DEST_LSB, DP_IMM_ARITHM_DEST_MSB);
                break;

            case DP_IMM_OPTYPE_WIDEMOV:
                inst->data.DPImmediateData.DPIOpType = a64inst_DPI_WIDEMOV;
                inst->data.DPImmediateData.processOpData.wideMovData.shiftScalar = getBits(wrd, DP_IMM_WIDEMOV_SHIFTSCALAR_LSB, DP_IMM_WIDEMOV_SHIFTSCALAR_MSB);
                inst->data.DPImmediateData.processOpData.wideMovData.immediate = getBits(wrd, DP_IMM_WIDEMOV_IMMVAL_LSB, DP_IMM_WIDEMOV_IMMVAL_MSB);
                break;

            default:
                fprintf(stderr, "Unknown immediate data processing operation type found!\n");
                exit(1);
                break;
        }

    } else if (typeId == BRANCH_ID) {
        inst->type = a64inst_BRANCH;
        word branchTypeFlag = getBits(wrd, BRANCH_TYPE_LSB, BRANCH_TYPE_MSB);
        
        inst->data.BranchData.BranchType = branchTypeFlag;

        switch (branchTypeFlag) {
            case a64inst_UNCONDITIONAL:
                inst->data.BranchData.processOpData.unconditionalData.unconditionalOffset = getBits(wrd, BRANCH_UNCONDITIONAL_OFFSET_LSB, BRANCH_UNCONDITIONAL_OFFSET_MSB);
                break;

            case a64inst_CONDITIONAL:
                inst->data.BranchData.processOpData.conditionalData.offset = getBits(wrd, BRANCH_CONDITIONAL_OFFSET_LSB, BRANCH_CONDITIONAL_OFFSET_MSB);
                
                word conditionFlag = getBits(wrd, BRANCH_CONDITIONAL_COND_LSB, BRANCH_CONDITIONAL_COND_MSB);

                if(conditionFlag <= 1 || (conditionFlag >= 10 && conditionFlag <= 14)) {
                    inst->data.BranchData.processOpData.conditionalData.cond = conditionFlag;
                } else {
                    fprintf(stderr, "Unknown condition detected!\n");
                    exit(1);
                }
                
                break;

            case a64inst_REGISTER:
                inst->data.BranchData.processOpData.registerData.src = getBits(wrd, BRANCH_REGISTER_SRC_LSB, BRANCH_REGISTER_SRC_MSB);
                break;

            default:
                fprintf(stderr, "Undefined branch type detected!\n");
                exit(1);
                break;
        }

    // TODO: Some minor code duplication between DPR and DPI data interpretation
    // Data Processing Register interpretation
    } else if (getBits(wrd, DP_REG_LSB, DP_REG_MSB) == 1) {
        inst->type = a64inst_DPREGISTER;
        inst->data.DPRegisterData.regType = getBits(wrd, DP_WIDTH_LSB, DP_WIDTH_MSB);
        inst->data.DPRegisterData.processOp = getBits(wrd, DP_OP_LSB, DP_OP_MSB);
        inst->data.DPRegisterData.dest = getBits(wrd, DP_DEST_LSB, DP_DEST_MSB);
        inst->data.DPRegisterData.src1 = getBits(wrd, DP_REG_SRC1_LSB, DP_REG_SRC1_MSB);
        inst->data.DPRegisterData.src2 = getBits(wrd, DP_REG_SRC2_LSB, DP_REG_SRC2_MSB);
        inst->data.DPRegisterData.DPROpType = getBits(wrd, DP_REG_OPTYPE_LSB, DP_REG_OPTYPE_MSB);
        
        a64inst_DPRegister_ArithmLogicData *arithmLogicData = &inst->data.DPRegisterData.processOpData.arithmLogicData;

        arithmLogicData->type = getBits(wrd, DP_REG_ARITHMLOGIC_ARITHMFLAG_LSB, DP_REG_ARITHMLOGIC_ARITHMFLAG_MSB);
        arithmLogicData->shiftType = getBits(wrd, DP_REG_ARITHMLOGIC_SHIFTTYPE_LSB, DP_REG_ARITHMLOGIC_SHIFTTYPE_MSB);
        arithmLogicData->negShiftedSrc2 = getBits(wrd, DP_REG_ARITHMLOGIC_NEGSRC2FLAG_LSB, DP_REG_ARITHMLOGIC_NEGSRC2FLAG_MSB);

        switch(inst->data.DPRegisterData.DPROpType) {

            case a64inst_DPR_ARITHMLOGIC:
                if (arithmLogicData->type == a64inst_DPR_ARITHM && (arithmLogicData->negShiftedSrc2 || arithmLogicData->shiftType == a64inst_ROR)) {
                    fprintf(stderr, "Attempting to decode arithmetic DPR instruction with invalid format!\n");
                }
                arithmLogicData->shiftAmount = getBits(wrd, DP_REG_ARITHMLOGIC_SHIFTAMOUNT_LSB, DP_REG_ARITHMLOGIC_SHIFTAMOUNT_MSB);
                break;
            
            case a64inst_DPR_MULTIPLY:;
                if (!(inst->data.DPRegisterData.processOp == DP_REG_MULTIPLY_PROCESSOP &&
                      arithmLogicData->type == DP_REG_MULTIPLY_ARITHMFLAG && 
                      arithmLogicData->shiftType == DP_REG_MULTIPLY_SHIFTTYPE &&
                      arithmLogicData->negShiftedSrc2 == DP_REG_MULTIPLY_NEGSRC2FLAG)) {
                    fprintf(stderr, "Attempting to decode multiply DPR instruction with invalid format!\n");
                }
                inst->data.DPRegisterData.processOpData.multiplydata.summand = getBits(wrd, DP_REG_MULTIPLY_SUMMAND_LSB, DP_REG_MULTIPLY_SUMMAND_MSB);
                inst->data.DPRegisterData.processOpData.multiplydata.negProd = getBits(wrd, DP_REG_MULTIPLY_NEGPROD_LSB, DP_REG_MULTIPLY_NEGPROD_MSB);
                break;
        }

    } else {
        // Load and Store, or unknown
        // Ignore unknown for now
        inst->type = a64inst_SINGLETRANSFER;
        inst->data.SingleTransferData.regType = getBits(wrd, SDT_REGTYPE_FLAG_LSB, SDT_REGTYPE_FLAG_MSB);
        inst->data.SingleTransferData.target = getBits(wrd, SDT_TARGET_REG_LSB, SDT_TARGET_REG_MSB);

        // TODO: Assert that the instruction is a Single Transfer indeed.

        if(getBits(wrd, SDT_OPTYPE_FLAG_LSB, SDT_OPTYPE_FLAG_MSB) == a64inst_SINGLE_TRANSFER_SINGLE_DATA_TRANSFER) {
            // Single Data Transfer
            inst->data.SingleTransferData.SingleTransferOpType = a64inst_SINGLE_TRANSFER_SINGLE_DATA_TRANSFER;
            inst->data.SingleTransferData.processOpData.singleDataTransferData.transferType = getBits(wrd, SDT_TRANSFER_TYPE_LSB, SDT_TRANSFER_TYPE_MSB);
            inst->data.SingleTransferData.processOpData.singleDataTransferData.base = getBits(wrd, SDT_BASE_REG_LSB, SDT_BASE_REG_MSB);
            if (getBits(wrd, SDT_UNSIGNED_FLAG_LSB, SDT_UNSIGNED_FLAG_MSB) == 1) {
                // Unsigned offset
                inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = a64inst_UNSIGNED_OFFSET;
                inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.unsignedOffset = getBits(wrd, SDT_OFFSET_LSB, SDT_OFFSET_MSB);
            } else if (getBits(wrd, SDT_REGISTER_FLAG_LSB, SDT_REGISTER_FLAG_MSB) == 1) {
                // Register Offset
                inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = a64inst_REGISTER_OFFSET;
                inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.offsetReg = getBits(wrd, SDT_REGISTER_REG_LSB, SDT_REGISTER_REG_MSB);
            } else {
                // Pre-Indexed or Post-Indexed
                inst->data.SingleTransferData.processOpData.singleDataTransferData.addressingMode = getBits(wrd, SDT_INDEXED_ADDRMODE_LSB, SDT_INDEXED_ADDRMODE_MSB);
                inst->data.SingleTransferData.processOpData.singleDataTransferData.a64inst_addressingModeData.indexedOffset = getBits(wrd, SDT_INDEXED_OFFSET_LSB, SDT_INDEXED_OFFSET_MSB);
            }
        } else {
            // Load Literal
            inst->data.SingleTransferData.SingleTransferOpType = a64inst_SINGLE_TRANSFER_LOAD_LITERAL;
            inst->data.SingleTransferData.processOpData.loadLiteralData.offset = getBits(wrd, SDT_LOAD_LITERAL_OFFSET_LSB, SDT_LOAD_LITERAL_OFFSET_MSB);
        }
    }
    
    return inst;
}