#include "cdio/compat/read.h"

#include "stdlib.h"

#include "cdio/compat/sector.h"


// Allocate the proper sizes in C, as Haskell marshalling for anything but
// simple `Storable` types is a bit awkward.

void read_bytes(const CdIo_t* cdio, void** buf, ssize_t* out, size_t bytes) {
    *buf = malloc(bytes);
    *out = cdio_read(cdio, *buf, bytes);
}


uint16_t sector_size(cdio_read_mode_t mode) {
    switch (mode) {
        case CDIO_READ_MODE_AUDIO:
            return CDIO_CD_FRAMESIZE_RAW;
        case CDIO_READ_MODE_M1F1:
            return CDIO_CD_FRAMESIZE;
        case CDIO_READ_MODE_M1F2:
            return CDIO_CD_FRAMESIZE_RAW0;
        case CDIO_READ_MODE_M2F1:
            return CDIO_CD_FRAMESIZE;
        case CDIO_READ_MODE_M2F2:
            return M2F2_SECTOR_SIZE;
        default:
            return 0;
    }
}

void setup_read(void** buff, uint32_t* bytes, uint16_t blocksize, uint32_t blocks) {
    *bytes = blocksize * blocks;
    *buff = malloc(*bytes);
}


// Marshalling aids

driver_return_code_t read_sector(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, cdio_read_mode_t mode) {
    setup_read(buff, bytes, sector_size(mode), 1);
    return cdio_read_sector(cdio, *buff, lsn, mode);
}

driver_return_code_t read_sectors(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, cdio_read_mode_t mode, uint32_t blocks) {
    setup_read(buff, bytes, sector_size(mode), blocks);
    return cdio_read_sectors(cdio, *buff, lsn, mode, blocks);
}


driver_return_code_t read_data_sectors(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, uint16_t blocksize, uint32_t blocks) {
    setup_read(buff, bytes, blocksize, blocks);
    return cdio_read_data_sectors(cdio, *buff, lsn, blocksize, blocks);
}


driver_return_code_t read_audio_sector(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn) {
    setup_read(buff, bytes, sector_size(CDIO_READ_MODE_AUDIO), 1);
    return cdio_read_audio_sector(cdio, *buff, lsn);
}

driver_return_code_t read_audio_sectors(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, uint32_t blocks) {
    setup_read(buff, bytes, sector_size(CDIO_READ_MODE_AUDIO), blocks);
    return cdio_read_audio_sectors(cdio, *buff, lsn, blocks);
}


driver_return_code_t read_mode1_sector(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, bool form2) {
    setup_read(buff, bytes, sector_size((form2 ? CDIO_READ_MODE_M1F2 : CDIO_READ_MODE_M1F1)), 1);
    return cdio_read_mode1_sector(cdio, *buff, lsn, form2);
}

driver_return_code_t read_mode1_sectors(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, bool form2, uint32_t blocks) {
    setup_read(buff, bytes, sector_size((form2 ? CDIO_READ_MODE_M1F2 : CDIO_READ_MODE_M1F1)), blocks);
    return cdio_read_mode1_sectors(cdio, *buff, lsn, form2, blocks);
}


driver_return_code_t read_mode2_sector(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, bool form2) {
    setup_read(buff, bytes, sector_size((form2 ? CDIO_READ_MODE_M2F2 : CDIO_READ_MODE_M2F1)), 1);
    return cdio_read_mode2_sector(cdio, *buff, lsn, form2);
}

driver_return_code_t read_mode2_sectors(const CdIo_t* cdio, void** buff, uint32_t* bytes, lsn_t lsn, bool form2, uint32_t blocks) {
    setup_read(buff, bytes, sector_size((form2 ? CDIO_READ_MODE_M2F2 : CDIO_READ_MODE_M2F1)), blocks);
    return cdio_read_mode2_sectors(cdio, *buff, lsn, form2, blocks);
}