#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

#include <xas/audio.h>
#include <xas/riff.h>

struct _xas_riff {
    const char *file;
    int fd;
    size_t size;

    size_t channels,
           sample_size,
           sample_rate;
};

static int header_write(xas_riff *riff) {
    xas_riff_wave_header header = {
        .riff = {
            {
                .id    = XAS_RIFF_HEADER_MAIN_ID,
                .size = sizeof(xas_riff_main_chunk)
                      + sizeof(xas_riff_wave_chunk)
                      + riff->size
            },

            .type = XAS_RIFF_HEADER_WAVE_ID,
        },

        .wave = {
            {
                .id   = XAS_RIFF_HEADER_WAVE_FMT_ID,
                .size = sizeof(xas_riff_wave_chunk)
                      - sizeof(xas_riff_chunk)
            },

            .type             = XAS_RIFF_WAVE_DEFAULT_TYPE,
            .channels         = riff->channels,
            .sample_rate      = riff->sample_rate,
            .byte_rate        = riff->channels * riff->sample_size * riff->sample_rate,
            .sample_size      = riff->sample_size,
            .sample_size_bits = riff->sample_size << 3
        },

        {
            .id   = XAS_RIFF_HEADER_WAVE_DATA_ID,
            .size = riff->size
        }
    };

    if (lseek(riff->fd, 0, SEEK_SET) < 0) {
        goto error_io;
    }

    if (write(riff->fd, &header, sizeof(header)) < 0) {
        goto error_io;
    }

    if (lseek(riff->fd, 0, SEEK_END) < 0) {
        goto error_io;
    }

    return 0;

error_io:
    return -1;
}

static xas_riff *new_file(const char *path,
                            size_t channels,
                            size_t sample_size,
                            size_t sample_rate,
                            int flags) {
    xas_riff *riff;

    if ((riff = malloc(sizeof(*riff))) == NULL) {
        goto error_malloc_riff;
    }

    flags |= O_CREAT;

    if ((riff->fd = open(path, flags, 0644)) < 0) {
        goto error_open;
    }

    riff->file        = path;
    riff->size        = 0;
    riff->channels    = channels;
    riff->sample_size = sample_size;
    riff->sample_rate = sample_rate;

    if (header_write(riff) < 0) {
        goto error_header_write;
    }

    return riff;

error_header_write:
    close(riff->fd);

error_open:
    free(riff);

error_malloc_riff:
    return NULL;
}

static int wave_header_parse(xas_riff *riff,
                             xas_riff_wave_header *header) {
    if (memcmp(header->riff.header.id,
               XAS_RIFF_HEADER_MAIN_ID,
               strlen(XAS_RIFF_HEADER_MAIN_ID)) != 0) {
        goto error_invalid_header_main_id;
    }

    if (header->riff.header.size < sizeof(xas_riff_main_chunk)
                                 + sizeof(xas_riff_wave_chunk)) {
        goto error_invalid_header_wave_chunk_size;
    }

    if (memcmp(header->riff.type,
               XAS_RIFF_HEADER_WAVE_ID,
               strlen(XAS_RIFF_HEADER_WAVE_ID)) != 0) {
        goto error_invalid_wave_chunk_id;
    }

    if (memcmp(header->wave.header.id,
               XAS_RIFF_HEADER_WAVE_FMT_ID,
               strlen(XAS_RIFF_HEADER_WAVE_FMT_ID)) != 0) {
        goto error_invalid_wave_format_id;
    }

    if (header->wave.header.size != sizeof(xas_riff_wave_chunk)
                                  - sizeof(xas_riff_chunk)) {
        goto error_invalid_wave_format_size;
    }

    if (header->wave.type != XAS_RIFF_WAVE_DEFAULT_TYPE) {
        goto error_invalid_wave_format_type;
    }

    switch (header->wave.channels) {
        case XAS_AUDIO_MONO:
        case XAS_AUDIO_STEREO:
            break;

        default:
            goto error_invalid_wave_channels;
    }

    if (header->wave.byte_rate != header->wave.channels
                                * header->wave.sample_size
                                * header->wave.sample_rate) {
        goto error_invalid_wave_byte_rate;
    }

    if (header->wave.sample_size_bits != header->wave.sample_size << 3) {
        goto error_invalid_wave_sample_size_bits;
    }

    if (memcmp(header->data.id,
               XAS_RIFF_HEADER_WAVE_DATA_ID,
               strlen(XAS_RIFF_HEADER_WAVE_DATA_ID)) != 0) {
        goto error_invalid_wave_data_format_id;
    }

    riff->channels    = header->wave.channels;
    riff->sample_size = header->wave.sample_size;
    riff->sample_rate = header->wave.sample_rate;

    return 0;

error_invalid_wave_data_format_id:
error_invalid_wave_sample_size_bits:
error_invalid_wave_byte_rate:
error_invalid_wave_channels:
error_invalid_wave_format_type:
error_invalid_wave_format_size:
error_invalid_wave_format_id:
error_invalid_wave_chunk_id:
error_invalid_header_wave_chunk_size:
error_invalid_header_main_id:
    return -1;
}

static xas_riff *open_fd(int fd) {
    xas_riff *riff;
    xas_riff_wave_header header;

    ssize_t readlen;

    if ((riff = malloc(sizeof(*riff))) == NULL) {
        goto error_malloc_riff;
    }

    riff->file        = NULL;
    riff->fd          = fd;
    riff->size        = 0;
    riff->channels    = 0;
    riff->sample_size = 0;
    riff->sample_rate = 0;

    if ((readlen = read(fd, &header, sizeof(header))) < 0) {
        goto error_read;
    }

    if (readlen != sizeof(header)) {
        errno= EINVAL;

        goto error_wave_header_short;
    }

    if (wave_header_parse(riff, &header) < 0) {
        goto error_wave_header_parse;
    }

    return riff;

error_wave_header_parse:
error_wave_header_short:
error_read:
    free(riff);

error_malloc_riff:
    return NULL;
}

static xas_riff *open_file(const char *path, int flags) {
    xas_riff *riff;
    xas_riff_wave_header header;

    ssize_t readlen;

    if ((riff = malloc(sizeof(*riff))) == NULL) {
        goto error_malloc_riff;
    }

    flags &= ~(O_CREAT | O_TRUNC);

    if ((riff->fd = open(path, flags)) < 0) {
        goto error_open;
    }

    riff->file        = path;
    riff->size        = 0;
    riff->channels    = 0;
    riff->sample_size = 0;
    riff->sample_rate = 0;

    if (lseek(riff->fd, 0, SEEK_SET) < 0) {
        goto error_lseek;
    }

    if ((readlen = read(riff->fd, &header, sizeof(header))) < 0) {
        goto error_read;
    }

    if (readlen != sizeof(header)) {
        errno= EINVAL;

        goto error_wave_header_short;
    }

    if (wave_header_parse(riff, &header) < 0) {
        goto error_wave_header_parse;
    }

    return riff;

error_wave_header_parse:
error_wave_header_short:
error_read:
error_lseek:
    close(riff->fd);

error_open:
    free(riff);

error_malloc_riff:
    return NULL;
}

static void close_file(xas_riff *riff, xas_audio_stream *stream) {
    if (lseek(riff->fd, 0, SEEK_SET) == 0) {
        (void)header_write(riff);
    }

    if (riff->file) {
        (void)close(riff->fd);
    }

    free(riff);
}

static ssize_t audio_drain(xas_riff *riff,
                           void *samples,
                           size_t count,
                           xas_audio_stream *stream) {
    size_t len = count * stream->channels
                       * stream->sample_size;

    ssize_t wrlen;

    if ((wrlen = write(riff->fd, samples, len)) < 0) {
        goto error_write;
    }

    riff->size += wrlen;

    return wrlen / stream->channels / stream->sample_size;

error_write:
    return -1;
}

static ssize_t audio_fill(xas_riff *riff,
                          void *samples,
                          size_t count,
                          xas_audio_stream *stream) {
    size_t len = count * stream->channels
                       * stream->sample_size;

    ssize_t rdlen;

    if ((rdlen = read(riff->fd, samples, len)) < 0) {
        goto error_read;
    }

    return rdlen / stream->channels / stream->sample_size;

error_read:
    return -1;
}

xas_audio_stream *xas_riff_new_file(const char *path,
                                        size_t channels,
                                        size_t sample_size,
                                        size_t sample_rate,
                                        int flags) {
    xas_audio_stream *stream;
    xas_riff *riff;

    if ((riff = new_file(path,
                         channels,
                         sample_size,
                         sample_rate,
                         flags)) == NULL) {
        goto error_new_file;
    }

    if (flags & (O_RDWR | O_WRONLY)) {
        if ((stream = xas_audio_stream_new_sink((xas_audio_drain)audio_drain,
                                                  (xas_audio_cleanup)close_file,
                                                  riff,
                                                  channels,
                                                  sample_size,
                                                  sample_rate,
                                                  4096)) == NULL) {
            goto error_audio_stream_new_sink;
        }
    } else {
        if ((stream = xas_audio_stream_new_source((xas_audio_fill)audio_fill,
                                                    (xas_audio_cleanup)close_file,
                                                    riff,
                                                    channels,
                                                    sample_size,
                                                    sample_rate,
                                                    4096)) == NULL) {
            goto error_audio_stream_new_sink;
        }
    }

    return stream;

error_audio_stream_new_sink:
    close_file(riff, NULL);

error_new_file:
    return NULL;
}

xas_audio_stream *xas_riff_open_file(const char *path, int flags) {
    xas_audio_stream *stream;
    xas_riff *riff;

    if ((riff = open_file(path, flags)) == NULL) {
        goto error_open_file;
    }

    if (flags & (O_RDWR | O_WRONLY)) {
        if ((stream = xas_audio_stream_new_sink((xas_audio_drain)audio_drain,
                                                  (xas_audio_cleanup)close_file,
                                                  riff,
                                                  riff->channels,
                                                  riff->sample_size,
                                                  riff->sample_rate,
                                                  4096)) == NULL) {
            goto error_audio_stream_new_sink;
        }
    } else {
        if ((stream = xas_audio_stream_new_source((xas_audio_fill)audio_fill,
                                                    (xas_audio_cleanup)close_file,
                                                    riff,
                                                    riff->channels,
                                                    riff->sample_size,
                                                    riff->sample_rate,
                                                    4096)) == NULL) {
            goto error_audio_stream_new_sink;
        }
    }

    return stream;

error_audio_stream_new_sink:
    close_file(riff, NULL);

error_open_file:
    return NULL;
}

xas_audio_stream *xas_riff_open_fd(int fd) {
    xas_audio_stream *stream;
    xas_riff *riff;

    if ((riff = open_fd(fd)) == NULL) {
        goto error_open_fd;
    }

    if ((stream = xas_audio_stream_new_source((xas_audio_fill)audio_fill,
                                                (xas_audio_cleanup)close_file,
                                                riff,
                                                riff->channels,
                                                riff->sample_size,
                                                riff->sample_rate,
                                                4096)) == NULL) {
        goto error_audio_stream_new_sink;
    }

    return stream;

error_audio_stream_new_sink:
    free(riff);

error_open_fd:
    return NULL;
}