/*  _______         ____    __         ___    ___
 * \    _  \       \    /  \  /       \   \  /   /       '   '  '
 *  |  | \  \       |  |    ||         |   \/   |         .      .
 *  |  |  |  |      |  |    ||         ||\  /|  |
 *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '
 *  |  |  |  |      |  |    ||         ||    |  |         .      .
 *  |  |_/  /        \  \__//          ||    |  |
 * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque
 *                                                      /  \
 *                                                     / .  \
 * readokt.c - Code to read an Oktalyzer module       / / \  \
 *             from an open file.                    | <  /   \_
 *                                                   |  \/ /\   /
 * By Christopher Snowhill.                           \_  /  > /
 *                                                      | \ / /
 *                                                      |  ' /
 *                                                       \__/
 */

#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "dumb.h"
#include "internal/it.h"

static int it_okt_read_pattern(IT_PATTERN *pattern, const unsigned char *data,
                               int length, int n_channels) {
    int pos;
    int channel;
    int row;
    int n_rows;
    IT_ENTRY *entry;

    if (length < 2)
        return -1;

    n_rows = (data[0] << 8) | data[1];
    if (!n_rows)
        n_rows = 64;

    if (length < 2 + (n_rows * n_channels * 4))
        return -1;

    pattern->n_rows = n_rows;

    /* compute number of entries */
    pattern->n_entries = n_rows; /* Account for the row end markers */
    pos = 2;
    for (row = 0; row < pattern->n_rows; row++) {
        for (channel = 0; channel < n_channels; channel++) {
            if (data[pos + 0] | data[pos + 2])
                pattern->n_entries++;
            pos += 4;
        }
    }

    pattern->entry =
        (IT_ENTRY *)malloc(pattern->n_entries * sizeof(*pattern->entry));
    if (!pattern->entry)
        return -1;

    entry = pattern->entry;
    pos = 2;
    for (row = 0; row < n_rows; row++) {
        for (channel = 0; channel < n_channels; channel++) {
            if (data[pos + 0] | data[pos + 2]) {
                entry->channel = channel;
                entry->mask = 0;

                if (data[pos + 0] > 0 && data[pos + 0] <= 36) {
                    entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT;

                    entry->note = data[pos + 0] + 35;
                    entry->instrument = data[pos + 1] + 1;
                }

                entry->effect = 0;
                entry->effectvalue = data[pos + 3];

                switch (data[pos + 2]) {
                case 2:
                    if (data[pos + 3])
                        entry->effect = IT_PORTAMENTO_DOWN;
                    break; // XXX code calls this rs_portu, but it's adding to
                           // the period, which decreases the pitch
                case 13:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_NOTE_SLIDE_DOWN;
                    break;
                case 21:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_NOTE_SLIDE_DOWN_ROW;
                    break;

                case 1:
                    if (data[pos + 3])
                        entry->effect = IT_PORTAMENTO_UP;
                    break; // XXX same deal here, increasing the pitch
                case 17:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_NOTE_SLIDE_UP;
                    break;
                case 30:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_NOTE_SLIDE_UP_ROW;
                    break;

                case 10:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_ARPEGGIO_3;
                    break;
                case 11:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_ARPEGGIO_4;
                    break;
                case 12:
                    if (data[pos + 3])
                        entry->effect = IT_OKT_ARPEGGIO_5;
                    break;

                case 15:
                    entry->effect = IT_S;
                    entry->effectvalue =
                        EFFECT_VALUE(IT_S_SET_FILTER, data[pos + 3] & 0x0F);
                    break;

                case 25:
                    entry->effect = IT_JUMP_TO_ORDER;
                    break;

                case 27:
                    entry->note = IT_NOTE_OFF;
                    entry->mask |= IT_ENTRY_NOTE;
                    break;

                case 28:
                    entry->effect = IT_SET_SPEED;
                    break;

                case 31:
                    if (data[pos + 3] <= 0x40)
                        entry->effect = IT_SET_CHANNEL_VOLUME;
                    else if (data[pos + 3] <= 0x50) {
                        entry->effect = IT_OKT_VOLUME_SLIDE_DOWN;
                        entry->effectvalue = data[pos + 3] - 0x40;
                    } else if (data[pos + 3] <= 0x60) {
                        entry->effect = IT_OKT_VOLUME_SLIDE_UP;
                        entry->effectvalue = data[pos + 3] - 0x50;
                    } else if (data[pos + 3] <= 0x70) {
                        entry->effect = IT_OKT_VOLUME_SLIDE_DOWN;
                        entry->effectvalue = data[pos + 3] - 0x50;
                    } else if (data[pos + 3] <= 0x80) {
                        entry->effect = IT_OKT_VOLUME_SLIDE_UP;
                        entry->effectvalue = data[pos + 3] - 0x60;
                    }
                    break;
                }

                if (entry->effect)
                    entry->mask |= IT_ENTRY_EFFECT;

                entry++;
            }
            pos += 4;
        }
        IT_SET_END_ROW(entry);
        entry++;
    }

    return 0;
}

static void it_okt_read_sample_header(IT_SAMPLE *sample,
                                      const unsigned char *data) {
    int loop_start, loop_length;

    memcpy(sample->name, data, 20);
    sample->name[20] = 0;

    sample->filename[0] = 0;

    sample->length =
        (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23];
    sample->global_volume = 64;
    sample->default_volume = data[29];
    loop_start = ((data[24] << 8) | data[25]) << 1;
    loop_length = ((data[26] << 8) | data[27]) << 1;
    sample->sus_loop_start = loop_start;
    sample->sus_loop_end = loop_start + loop_length;

    if (sample->length <= 0) {
        sample->flags = 0;
        return;
    }

    sample->flags = IT_SAMPLE_EXISTS;

    sample->default_pan = 0;
    sample->C5_speed =
        (int)(AMIGA_CLOCK /
              214.0); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32));
    sample->finetune = 0;

    if (sample->sus_loop_end > sample->length)
        sample->sus_loop_end = sample->length;

    if (loop_length > 2)
        sample->flags |= IT_SAMPLE_SUS_LOOP;

    sample->vibrato_speed = 0;
    sample->vibrato_depth = 0;
    sample->vibrato_rate = 0;
    sample->vibrato_waveform = 0; // do we have to set _all_ these?
    sample->max_resampling_quality = -1;
}

static int it_okt_read_sample_data(IT_SAMPLE *sample, const char *data,
                                   int length) {
    if (length && sample->length) {
        if (length < sample->length) {
            sample->length = length;
            if (length < sample->sus_loop_end)
                sample->sus_loop_end = length;
        }

        sample->data = malloc(length);

        if (!sample->data)
            return -1;

        memcpy(sample->data, data, length);
    }

    return 0;
}

typedef struct IFF_CHUNK IFF_CHUNK;
typedef struct IFF_CHUNKED IFF_CHUNKED;

struct IFF_CHUNK {
    unsigned type;
    unsigned char *data;
    unsigned size;
};

struct IFF_CHUNKED {
    unsigned chunk_count;
    IFF_CHUNK *chunks;
};

static IFF_CHUNKED *dumbfile_read_okt(DUMBFILE *f) {
    IFF_CHUNKED *mod = (IFF_CHUNKED *)malloc(sizeof(*mod));
    if (!mod)
        return NULL;

    mod->chunk_count = 0;
    mod->chunks = 0;

    for (;;) {
        long bytes_read;
        IFF_CHUNK *chunk = (IFF_CHUNK *)realloc(
            mod->chunks, (mod->chunk_count + 1) * sizeof(IFF_CHUNK));
        if (!chunk) {
            if (mod->chunks)
                free(mod->chunks);
            free(mod);
            return NULL;
        }
        mod->chunks = chunk;
        chunk += mod->chunk_count;

        bytes_read = dumbfile_mgetl(f);
        if (bytes_read < 0)
            break;

        chunk->type = (unsigned int)bytes_read;
        chunk->size = (unsigned int)dumbfile_mgetl(f);

        if (dumbfile_error(f))
            break;

        chunk->data = (unsigned char *)malloc(chunk->size);
        if (!chunk->data) {
            free(mod->chunks);
            free(mod);
            return NULL;
        }

        bytes_read = dumbfile_getnc((char *)chunk->data, chunk->size, f);
        if (bytes_read < chunk->size) {
            if (bytes_read <= 0) {
                free(chunk->data);
                break;
            } else {
                chunk->size = (unsigned int)bytes_read;
                mod->chunk_count++;
                break;
            }
        }

        mod->chunk_count++;
    }

    if (!mod->chunk_count) {
        if (mod->chunks)
            free(mod->chunks);
        free(mod);
        mod = NULL;
    }

    return mod;
}

void free_okt(IFF_CHUNKED *mod) {
    unsigned i;
    if (mod) {
        if (mod->chunks) {
            for (i = 0; i < mod->chunk_count; i++) {
                if (mod->chunks[i].data)
                    free(mod->chunks[i].data);
            }
            free(mod->chunks);
        }
        free(mod);
    }
}

const IFF_CHUNK *get_chunk_by_type(IFF_CHUNKED *mod, unsigned type,
                                   unsigned offset) {
    unsigned i;
    if (mod) {
        if (mod->chunks) {
            for (i = 0; i < mod->chunk_count; i++) {
                if (mod->chunks[i].type == type) {
                    if (!offset)
                        return &mod->chunks[i];
                    else
                        offset--;
                }
            }
        }
    }
    return NULL;
}

unsigned get_chunk_count(IFF_CHUNKED *mod, unsigned type) {
    unsigned i, count = 0;
    if (mod) {
        if (mod->chunks) {
            for (i = 0; i < mod->chunk_count; i++) {
                if (mod->chunks[i].type == type)
                    count++;
            }
        }
    }
    return count;
}

static DUMB_IT_SIGDATA *it_okt_load_sigdata(DUMBFILE *f) {
    DUMB_IT_SIGDATA *sigdata;
    int n_channels;
    int i, j, k, l;
    IFF_CHUNKED *mod;
    const IFF_CHUNK *chunk;

    char signature[8];

    if (dumbfile_getnc(signature, 8, f) < 8 ||
        memcmp(signature, "OKTASONG", 8)) {
        return NULL;
    }

    mod = dumbfile_read_okt(f);
    if (!mod)
        return NULL;

    sigdata = (DUMB_IT_SIGDATA *)malloc(sizeof(*sigdata));
    if (!sigdata) {
        free_okt(mod);
        return NULL;
    }

    sigdata->name[0] = 0;

    chunk = get_chunk_by_type(mod, DUMB_ID('S', 'P', 'E', 'E'), 0);
    if (!chunk || chunk->size < 2) {
        free(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->speed = (chunk->data[0] << 8) | chunk->data[1];

    chunk = get_chunk_by_type(mod, DUMB_ID('S', 'A', 'M', 'P'), 0);
    if (!chunk || chunk->size < 32) {
        free(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->n_samples = chunk->size / 32;

    chunk = get_chunk_by_type(mod, DUMB_ID('C', 'M', 'O', 'D'), 0);
    if (!chunk || chunk->size < 8) {
        free(sigdata);
        free_okt(mod);
        return NULL;
    }

    n_channels = 0;

    for (i = 0; i < 4; i++) {
        j = (chunk->data[i * 2] << 8) | chunk->data[i * 2 + 1];
        if (!j)
            n_channels++;
        else if (j == 1)
            n_channels += 2;
    }

    if (!n_channels) {
        free(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->n_pchannels = n_channels;

    sigdata->sample =
        (IT_SAMPLE *)malloc(sigdata->n_samples * sizeof(*sigdata->sample));
    if (!sigdata->sample) {
        free(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->song_message = NULL;
    sigdata->order = NULL;
    sigdata->instrument = NULL;
    sigdata->pattern = NULL;
    sigdata->midi = NULL;
    sigdata->checkpoint = NULL;

    sigdata->n_instruments = 0;

    for (i = 0; i < sigdata->n_samples; i++)
        sigdata->sample[i].data = NULL;

    chunk = get_chunk_by_type(mod, DUMB_ID('S', 'A', 'M', 'P'), 0);

    for (i = 0; i < sigdata->n_samples; i++) {
        it_okt_read_sample_header(&sigdata->sample[i], chunk->data + 32 * i);
    }

    sigdata->restart_position = 0;

    chunk = get_chunk_by_type(mod, DUMB_ID('P', 'L', 'E', 'N'), 0);
    if (!chunk || chunk->size < 2) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->n_orders = (chunk->data[0] << 8) | chunk->data[1];
    // what if this is > 128?

    if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    chunk = get_chunk_by_type(mod, DUMB_ID('P', 'A', 'T', 'T'), 0);
    if (!chunk || chunk->size < (unsigned)sigdata->n_orders) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->order = (unsigned char *)malloc(sigdata->n_orders);
    if (!sigdata->order) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    memcpy(sigdata->order, chunk->data, sigdata->n_orders);

    /* Work out how many patterns there are. */
    chunk = get_chunk_by_type(mod, DUMB_ID('S', 'L', 'E', 'N'), 0);
    if (!chunk || chunk->size < 2) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->n_patterns = (chunk->data[0] << 8) | chunk->data[1];

    j = get_chunk_count(mod, DUMB_ID('P', 'B', 'O', 'D'));
    if (sigdata->n_patterns > j)
        sigdata->n_patterns = j;

    if (!sigdata->n_patterns) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }

    sigdata->pattern =
        (IT_PATTERN *)malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));
    if (!sigdata->pattern) {
        _dumb_it_unload_sigdata(sigdata);
        free_okt(mod);
        return NULL;
    }
    for (i = 0; i < sigdata->n_patterns; i++)
        sigdata->pattern[i].entry = NULL;

    /* Read in the patterns */
    for (i = 0; i < sigdata->n_patterns; i++) {
        chunk = get_chunk_by_type(mod, DUMB_ID('P', 'B', 'O', 'D'), i);
        if (it_okt_read_pattern(&sigdata->pattern[i], chunk->data, chunk->size,
                                n_channels) != 0) {
            _dumb_it_unload_sigdata(sigdata);
            free_okt(mod);
            return NULL;
        }
    }

    /* And finally, the sample data */
    k = get_chunk_count(mod, DUMB_ID('S', 'B', 'O', 'D'));
    for (i = 0, j = 0; i < sigdata->n_samples && j < k; i++) {
        if (sigdata->sample[i].flags & IT_SAMPLE_EXISTS) {
            chunk = get_chunk_by_type(mod, DUMB_ID('S', 'B', 'O', 'D'), j);
            if (it_okt_read_sample_data(&sigdata->sample[i],
                                        (const char *)chunk->data,
                                        chunk->size)) {
                _dumb_it_unload_sigdata(sigdata);
                free_okt(mod);
                return NULL;
            }
            j++;
        }
    }
    for (; i < sigdata->n_samples; i++) {
        sigdata->sample[i].flags = 0;
    }

    chunk = get_chunk_by_type(mod, DUMB_ID('C', 'M', 'O', 'D'), 0);

    for (i = 0, j = 0; i < n_channels && j < 4; j++) {
        k = (chunk->data[j * 2] << 8) | chunk->data[j * 2 + 1];
        l = (j == 1 || j == 2) ? 48 : 16;
        if (k == 0) {
            sigdata->channel_pan[i++] = l;
        } else if (k == 1) {
            sigdata->channel_pan[i++] = l;
            sigdata->channel_pan[i++] = l;
        }
    }

    free_okt(mod);

    /* Now let's initialise the remaining variables, and we're done! */
    sigdata->flags = IT_WAS_AN_OKT | IT_WAS_AN_XM | IT_WAS_A_MOD |
                     IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO;

    sigdata->global_volume = 128;
    sigdata->mixing_volume = 48;
    /* We want 50 ticks per second; 50/6 row advances per second;
     * 50*10=500 row advances per minute; 500/4=125 beats per minute.
     */
    sigdata->tempo = 125;
    sigdata->pan_separation = 128;

    memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);
    memset(sigdata->channel_pan + n_channels, 32,
           DUMB_IT_N_CHANNELS - n_channels);

    if (_dumb_it_fix_invalid_orders(sigdata) < 0) {
        _dumb_it_unload_sigdata(sigdata);
        return NULL;
    }

    return sigdata;
}

DUH *dumb_read_okt_quick(DUMBFILE *f) {
    sigdata_t *sigdata;

    DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

    sigdata = it_okt_load_sigdata(f);

    if (!sigdata)
        return NULL;

    {
        const char *tag[1][2];
        tag[0][0] = "FORMAT";
        tag[0][1] = "Oktalyzer";
        return make_duh(-1, 1, (const char *const(*)[2])tag, 1, &descptr,
                        &sigdata);
    }
}
