/*
 * Copyright 2007-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "cdda.h"

#include <KernelExport.h>
#include <device/scsi.h>

#include <algorithm>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>


struct cdtext_pack_data {
        uint8   id;
        uint8   track;
        uint8   number;
        uint8   character_position : 4;
        uint8   block_number : 3;
        uint8   double_byte : 1;
        char    text[12];
        uint8   crc[2];
} _PACKED;

enum {
        kTrackID        = 0x80,
        kArtistID       = 0x81,
        kMessageID      = 0x85,
};

static const uint32 kBufferSize = 16384;
static const uint32 kSenseSize = 1024;


//      #pragma mark - string functions


static char *
copy_string(const char *string)
{
        if (string == NULL || !string[0])
                return NULL;

        return strdup(string);
}


static char *
to_utf8(const char* string)
{
        char buffer[256];
        size_t out = 0;

        // TODO: assume CP1252 or ISO-8859-1 character set for now
        while (uint32 c = (uint8)string[0]) {

                if (c < 0x80) {
                        if (out >= sizeof(buffer) - 1)
                                break;
                        // ASCII character: no change needed
                        buffer[out++] = c;
                } else {
                        if (c < 0xA0) {
                                // Windows CP-1252 - Use a lookup table
                                static const uint32 lookup[] = {
                                        0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
                                        0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0, 0x017D, 0,
                                        0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
                                        0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0, 0x017E, 0x0178
                                };

                                c = lookup[c - 0x80];
                        }

                        // Convert to 2 or 3-byte representation
                        if (c == 0) {
                                // invalid character, ignore
                        } else if (c < 0x800) {
                                if (out >= sizeof(buffer) - 2)
                                        break;
                                buffer[out++] = 0xc0 | (c >> 6);
                                buffer[out++] = 0x80 | (c & 0x3f);
                        } else {
                                if (out >= sizeof(buffer) - 3)
                                        break;
                                buffer[out++] = 0xe0 | (c >> 12);
                                buffer[out++] = 0x80 | ((c >> 6) & 0x3f);
                                buffer[out++] = 0x80 | (c & 0x3f);
                        }
                }

                string++;
        }
        buffer[out++] = '\0';

        char *copy = (char *)malloc(out);
        if (copy == NULL)
                return NULL;

        memcpy(copy, buffer, out);
        return copy;
}


static bool
is_garbage(char c)
{
        return isspace(c) || c == '-' || c == '/' || c == '\\';
}


static void
sanitize_string(char *&string)
{
        if (string == NULL)
                return;

        // strip garbage at the start

        uint32 length = strlen(string);
        uint32 garbage = 0;
        while (is_garbage(string[garbage])) {
                garbage++;
        }

        length -= garbage;
        if (garbage)
                memmove(string, string + garbage, length + 1);

        // strip garbage from the end

        while (length > 1 && isspace(string[length - 1])) {
                string[--length] = '\0';
        }

        if (!string[0]) {
                // free string if it's empty
                free(string);
                string = NULL;
        }
}


//! Finds the first occurrence of \a find in \a string, ignores case.
static char*
find_string(const char *string, const char *find)
{
        if (string == NULL || find == NULL)
                return NULL;

        char first = tolower(find[0]);
        if (first == '\0')
                return (char *)string;

        int32 findLength = strlen(find) - 1;
        find++;

        for (; string[0]; string++) {
                if (tolower(string[0]) != first)
                        continue;
                if (strncasecmp(string + 1, find, findLength) == 0)
                        return (char *)string;
        }

        return NULL;
}


static void
cut_string(char *string, const char *cut)
{
        if (string == NULL || cut == NULL)
                return;

        char *found = find_string(string, cut);
        if (found != NULL) {
                uint32 foundLength = strlen(found);
                uint32 cutLength = strlen(cut);
                memmove(found, found + cutLength, foundLength + 1 - cutLength);
        }
}


static void
sanitize_album(cdtext &text)
{
        cut_string(text.album, text.artist);
        sanitize_string(text.album);

        if (text.album != NULL && !strcasecmp(text.album, "My CD")) {
                // don't laugh, people really do that!
                free(text.album);
                text.album = NULL;
        }

        if ((text.artist == NULL || text.artist[0] == '\0') && text.album != NULL) {
                // try to extract artist from album
                char *space = strstr(text.album, "  ");
                if (space != NULL) {
                        space[0] = '\0';
                        text.artist = text.album;
                        text.album = copy_string(space + 2);

                        sanitize_string(text.artist);
                        sanitize_string(text.album);
                }
        }
}


static void
sanitize_titles(cdtext &text)
{
        for (uint8 i = 0; i < text.track_count; i++) {
                cut_string(text.titles[i], "(Album Version)");
                sanitize_string(text.titles[i]);
                sanitize_string(text.artists[i]);

                if (text.artists[i] != NULL && text.artist != NULL
                        && !strcasecmp(text.artists[i], text.artist)) {
                        // if the title artist is the same as the main artist, remove it
                        free(text.artists[i]);
                        text.artists[i] = NULL;
                }

                if (text.titles[i] != NULL && text.titles[i][0] == '\t' && i > 0)
                        text.titles[i] = copy_string(text.titles[i - 1]);
        }
}


static bool
single_case(const char *string, bool &upper, bool &first)
{
        if (string == NULL)
                return true;

        while (string[0]) {
                while (!isalpha(string[0])) {
                        string++;
                }

                if (first) {
                        upper = isupper(string[0]) != 0;
                        first = false;
                } else if ((isupper(string[0]) != 0) ^ upper)
                        return false;

                string++;
        }

        return true;
}


static void
capitalize_string(char *string)
{
        if (string == NULL)
                return;

        bool newWord = isalpha(string[0]) || isspace(string[0]);
        while (string[0]) {
                if (isalpha(string[0])) {
                        if (newWord) {
                                string[0] = toupper(string[0]);
                                newWord = false;
                        } else
                                string[0] = tolower(string[0]);
                } else if (string[0] != '\'')
                        newWord = true;

                string++;
        }
}


static void
correct_case(cdtext &text)
{
        // check if all titles share a single case
        bool first = true;
        bool upper;
        if (!single_case(text.album, upper, first)
                || !single_case(text.artist, upper, first))
                return;

        for (int32 i = 0; i < text.track_count; i++) {
                if (!single_case(text.titles[i], upper, first)
                        || !single_case(text.artists[i], upper, first))
                        return;
        }

        // If we get here, everything has a single case; we fix that
        // and capitalize each word

        capitalize_string(text.album);
        capitalize_string(text.artist);
        for (int32 i = 0; i < text.track_count; i++) {
                capitalize_string(text.titles[i]);
                capitalize_string(text.artists[i]);
        }
}


//      #pragma mark - CD-Text


cdtext::cdtext()
        :
        artist(NULL),
        album(NULL),
        genre(NULL),
        track_count(0)
{
        memset(titles, 0, sizeof(titles));
        memset(artists, 0, sizeof(artists));
}


cdtext::~cdtext()
{
        free(album);
        free(artist);
        free(genre);

        for (uint8 i = 0; i < track_count; i++) {
                free(titles[i]);
                free(artists[i]);
        }
}


static bool
is_string_id(uint8 id)
{
        return id >= kTrackID && id <= kMessageID;
}


/*!     Parses a \a pack data into the provided text buffer; the corresponding
        track number will be left in \a track, and the type of the data in \a id.
        The pack data is explained in SCSI MMC-3.

        \a id, \a track, and \a state must stay constant between calls to this
        function. \a state must be initialized to zero for the first call.
*/
static bool
parse_pack_data(cdtext_pack_data *&pack, uint32 &packLeft,
        cdtext_pack_data *&lastPack, uint8 &id, uint8 &track, uint8 &state,
        char *buffer, size_t &length)
{
        if (packLeft < sizeof(cdtext_pack_data))
                return false;

        uint8 number = pack->number;
        size_t size = length;

        if (state != 0) {
                // we had a terminated string and a missing track
                track++;

                memcpy(buffer, lastPack->text + state, 12 - state);
                if (pack->track - track == 1)
                        state = 0;
                else
                        state += strnlen(buffer, 12 - state);
                return true;
        }

        id = pack->id;
        track = pack->track;

        buffer[0] = '\0';
        length = 0;

        size_t position = pack->character_position;
        if (position > 0 && lastPack != NULL) {
                memcpy(buffer, &lastPack->text[12 - position], position);
                length = position;
        }

        while (id == pack->id && track == pack->track) {
#if 0
                dprintf("%u.%u.%u, %u.%u.%u, ", pack->id, pack->track, pack->number,
                        pack->double_byte, pack->block_number, pack->character_position);
                for (int32 i = 0; i < 12; i++) {
                        if (isprint(pack->text[i]))
                                dprintf("%c", pack->text[i]);
                        else
                                dprintf("-");
                }
                dprintf("\n");
#endif
                if (is_string_id(id)) {
                        // TODO: support double byte characters
                        if (length + 12 < size) {
                                memcpy(buffer + length, pack->text, 12);
                                length += 12;
                        }
                }

                packLeft -= sizeof(cdtext_pack_data);
                if (packLeft < sizeof(cdtext_pack_data))
                        return false;

                lastPack = pack;
                number++;
                pack++;

                if (pack->number != number)
                        return false;
        }

        if (id == pack->id) {
                length -= pack->character_position;
                if (length >= size)
                        length = size - 1;
                buffer[length] = '\0';

                if (pack->track > lastPack->track + 1) {
                        // there is a missing track
                        for (int32 i = 0; i < 12; i++) {
                                if (lastPack->text[i] == '\0') {
                                        state = i + (lastPack->double_byte ? 2 : 1);
                                        break;
                                }
                        }
                }
        }

        return true;
}


static void
dump_cdtext(cdtext &text)
{
        if (text.album)
                dprintf("Album:    \"%s\"\n", text.album);
        if (text.artist)
                dprintf("Artist:   \"%s\"\n", text.artist);
        for (uint8 i = 0; i < text.track_count; i++) {
                dprintf("Track %02u: \"%s\"%s%s%s\n", i + 1, text.titles[i],
                        text.artists[i] ? " (" : "", text.artists[i] ? text.artists[i] : "",
                        text.artists[i] ? ")" : "");
        }
}


static void
dump_toc(scsi_toc_toc *toc)
{
        int32 numTracks = toc->last_track + 1 - toc->first_track;

        for (int32 i = 0; i < numTracks; i++) {
                scsi_toc_track& track = toc->tracks[i];
                scsi_cd_msf& next = toc->tracks[i + 1].start.time;
                        // the last track is always lead-out
                scsi_cd_msf& start = toc->tracks[i].start.time;
                scsi_cd_msf length;

                uint64 diff = next.minute * kFramesPerMinute
                        + next.second * kFramesPerSecond + next.frame
                        - start.minute * kFramesPerMinute
                        - start.second * kFramesPerSecond - start.frame;
                length.minute = diff / kFramesPerMinute;
                length.second = (diff % kFramesPerMinute) / kFramesPerSecond;
                length.frame = diff % kFramesPerSecond;

                dprintf("%02u. %02u:%02u.%02u (length %02u:%02u.%02u)\n",
                        track.track_number, start.minute, start.second, start.frame,
                        length.minute, length.second, length.frame);
        }
}


static status_t
read_frames(int fd, off_t firstFrame, uint8 *buffer, size_t count)
{
        size_t framesLeft = count;

        while (framesLeft > 0) {
                // If the initial count was >= 32, and not a multiple of 8, and the
                // ioctl fails, we switch to reading 8 frames at a time. However the
                // last read can read between 1 and 7 frames only, to not overflow
                // the buffer.
                count = std::min(count, framesLeft);

                scsi_read_cd read;
                read.start_m = firstFrame / kFramesPerMinute;
                read.start_s = (firstFrame / kFramesPerSecond) % 60;
                read.start_f = firstFrame % kFramesPerSecond;

                read.length_m = count / kFramesPerMinute;
                read.length_s = (count / kFramesPerSecond) % 60;
                read.length_f = count % kFramesPerSecond;

                read.buffer_length = count * kFrameSize;
                read.buffer = (char *)buffer;
                read.play = false;

                if (ioctl(fd, B_SCSI_READ_CD, &read, sizeof(scsi_read_cd)) < 0) {
                        // drive couldn't read data - try again to read with a smaller block size
                        if (count == 1)
                                return errno;

                        if (count >= 32)
                                count = 8;
                        else
                                count = 1;

                        continue;
                }

                buffer += count * kFrameSize;
                framesLeft -= count;
                firstFrame += count;
        }

        return B_OK;
}


static status_t
read_table_of_contents(int fd, uint32 track, uint8 format, uint8 *buffer,
        size_t bufferSize)
{
        raw_device_command raw;
        uint8 *senseData = (uint8 *)malloc(kSenseSize);
        if (senseData == NULL)
                return B_NO_MEMORY;

        memset(&raw, 0, sizeof(raw_device_command));
        memset(senseData, 0, kSenseSize);
        memset(buffer, 0, bufferSize);

        scsi_cmd_read_toc &toc = *(scsi_cmd_read_toc*)&raw.command;
        toc.opcode = SCSI_OP_READ_TOC;
        toc.time = 1;
        toc.format = format;
        toc.track = track;
        toc.allocation_length = B_HOST_TO_BENDIAN_INT16(bufferSize);

        raw.command_length = 10;
        raw.flags = B_RAW_DEVICE_DATA_IN | B_RAW_DEVICE_REPORT_RESIDUAL
                | B_RAW_DEVICE_SHORT_READ_VALID;
        raw.scsi_status = 0;
        raw.cam_status = 0;
        raw.data = buffer;
        raw.data_length = bufferSize;
        raw.timeout = 10000000LL;       // 10 secs
        raw.sense_data = senseData;
        raw.sense_data_length = sizeof(kSenseSize);

        if (ioctl(fd, B_RAW_DEVICE_COMMAND, &raw, sizeof(raw)) == 0
                && raw.scsi_status == 0 && raw.cam_status == 1) {
                free(senseData);
                return B_OK;
        }

        free(senseData);
        return B_ERROR;
}


//      #pragma mark - exported functions


status_t
read_cdtext(int fd, struct cdtext &cdtext)
{
        uint8 *buffer = (uint8 *)malloc(kBufferSize);
        if (buffer == NULL)
                return B_NO_MEMORY;

        // do it twice, just in case...
        // (at least my CD-ROM sometimes returned broken data on first try)
        read_table_of_contents(fd, 1, SCSI_TOC_FORMAT_CD_TEXT, buffer,
                kBufferSize);
        if (read_table_of_contents(fd, 1, SCSI_TOC_FORMAT_CD_TEXT, buffer,
                        kBufferSize) != B_OK) {
                free(buffer);
                return B_ERROR;
        }

        scsi_toc_general *header = (scsi_toc_general *)buffer;

        uint32 packLength = B_BENDIAN_TO_HOST_INT16(header->data_length) - 2;
        cdtext_pack_data *pack = (cdtext_pack_data *)(header + 1);
        cdtext_pack_data *lastPack = NULL;
        uint8 state = 0;
        uint8 track = 0;
        uint8 id = 0;
        char text[256];

        // TODO: determine encoding!

        while (true) {
                size_t length = sizeof(text);

                if (!parse_pack_data(pack, packLength, lastPack, id, track,
                                state, text, length))
                        break;

                switch (id) {
                        case kTrackID:
                                if (track == 0) {
                                        if (cdtext.album == NULL)
                                                cdtext.album = to_utf8(text);
                                } else if (track <= kMaxTracks) {
                                        if (cdtext.titles[track - 1] == NULL)
                                                cdtext.titles[track - 1] = to_utf8(text);
                                        if (track > cdtext.track_count)
                                                cdtext.track_count = track;
                                }
                                break;

                        case kArtistID:
                                if (track == 0) {
                                        if (cdtext.artist == NULL)
                                                cdtext.artist = to_utf8(text);
                                } else if (track <= kMaxTracks) {
                                        if (cdtext.artists[track - 1] == NULL)
                                                cdtext.artists[track - 1] = to_utf8(text);
                                }
                                break;

                        default:
                                if (is_string_id(id))
                                        dprintf("UNKNOWN %u: \"%s\"\n", id, text);
                                break;
                }
        }

        free(buffer);

        if (cdtext.artist == NULL && cdtext.album == NULL)
                return B_ERROR;

        for (int i = 0; i < cdtext.track_count; i++) {
                if (cdtext.titles[i] == NULL)
                        return B_ERROR;
        }

        sanitize_string(cdtext.artist);
        sanitize_album(cdtext);
        sanitize_titles(cdtext);
        correct_case(cdtext);

        dump_cdtext(cdtext);
        return B_OK;
}


status_t
read_table_of_contents(int fd, scsi_toc_toc *toc, size_t length)
{
        status_t status = read_table_of_contents(fd, 1, SCSI_TOC_FORMAT_TOC,
                (uint8*)toc, length);
        if (status < B_OK)
                return status;

        // make sure the values in the TOC make sense

        int32 lastTrack = toc->last_track + 1 - toc->first_track;
        size_t dataLength = B_BENDIAN_TO_HOST_INT16(toc->data_length) + 2;
        if (dataLength < sizeof(scsi_toc_toc) || lastTrack <= 0)
                return B_BAD_DATA;

        if (length > dataLength)
                length = dataLength;

        length -= sizeof(scsi_toc_general);

        if (lastTrack * sizeof(scsi_toc_track) > length)
                toc->last_track = length / sizeof(scsi_toc_track) + toc->first_track;

        dump_toc(toc);
        return B_OK;
}


status_t
read_cdda_data(int fd, off_t endFrame, off_t offset, void *data, size_t length,
        off_t bufferOffset, void *buffer, size_t bufferSize)
{
        if (bufferOffset >= 0 && bufferOffset <= offset + (off_t)length
                && bufferOffset + (off_t)bufferSize > offset) {
                if (offset >= bufferOffset) {
                        // buffer reaches into the beginning of the request
                        off_t dataOffset = offset - bufferOffset;
                        size_t bytes = min_c(bufferSize - dataOffset, length);
                        if (user_memcpy(data, (uint8 *)buffer + dataOffset, bytes) < B_OK)
                                return B_BAD_ADDRESS;

                        data = (void *)((uint8 *)data + bytes);
                        length -= bytes;
                        offset += bytes;
                } else if (offset < bufferOffset
                        && offset + length < bufferOffset + bufferSize) {
                        // buffer overlaps at the end of the request
                        off_t dataOffset = bufferOffset - offset;
                        size_t bytes = length - dataOffset;
                        if (user_memcpy((uint8 *)data + dataOffset, buffer, bytes) < B_OK)
                                return B_BAD_ADDRESS;

                        length -= bytes;
                }
                // we don't handle the case where we would need to split the request
        }

        while (length > 0) {
                off_t frame = offset / kFrameSize;
                uint32 count = bufferSize / kFrameSize;
                if (frame + count > endFrame)
                        count = endFrame - frame;

                status_t status = read_frames(fd, frame, (uint8 *)buffer, count);
                if (status < B_OK)
                        return status;

                off_t dataOffset = offset % kFrameSize;
                size_t bytes = bufferSize - dataOffset;
                if (bytes > length)
                        bytes = length;

                if (user_memcpy(data, (uint8 *)buffer + dataOffset, bytes) < B_OK)
                        return B_BAD_ADDRESS;

                data = (void *)((uint8 *)data + bytes);
                length -= bytes;
                offset += bytes;
        }

        return B_OK;
}