/* Copyright (C) 2007 Brian Koropoff <bkoropoff at gmail com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

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

#define EXTENDED_OFFSET 0x10200
#define EXTENDED_MAGIC ((guint32) ('x' << 0 | 'i' << 8 | 'd' << 16 | '6' << 24))

#define TYPE_LENGTH 0x0
#define TYPE_STRING 0x1
#define TYPE_INTEGER 0x4

#define TAG_TITLE 0x01
#define TAG_GAME 0x02
#define TAG_ARTIST 0x03
#define TAG_DUMPER 0x04
#define TAG_DUMP_DATE 0x05
#define TAG_EMULATOR 0x06
#define TAG_COMMENT 0x07
#define TAG_ALBUM 0x10
#define TAG_DISC 0x11
#define TAG_TRACK 0x12
#define TAG_PUBLISHER 0x13
#define TAG_YEAR 0x14
#define TAG_INTRO 0x30
#define TAG_LOOP 0x31
#define TAG_END 0x32
#define TAG_FADE 0x33
#define TAG_MUTED 0x34
#define TAG_COUNT 0x35
#define TAG_AMP 0x36

#define READ_INT8(data, offset) (data[offset])
#define READ_INT16(data, offset) ((data[offset] << 0) + (data[offset+1] << 8))
#define READ_INT24(data, offset) ((data[offset] << 0) + (data[offset+1] << 8) + (data[offset+2] << 16))
#define READ_INT32(data, offset) ((data[offset] << 0) + (data[offset+1] << 8) + (data[offset+2] << 16) + (data[offset+3] << 24))

static inline gboolean
spc_tag_is_extended (guchar * data, guint length)
{
  // Extended tags come at the end of the file (at a known offset)
  // and start with "xid6"
  return (length > EXTENDED_OFFSET + 4
      && READ_INT32 (data, EXTENDED_OFFSET) == EXTENDED_MAGIC);
}

static inline gboolean
spc_tag_is_text_format (guchar * data, guint length)
{
  // Because the id666 format is brain dead, there's
  // no definite way to decide if it is in text
  // format.  This function implements a set of
  // heuristics to make a best-effort guess.

  // If the date field contains separators, it is probably text
  if (data[0xA0] == '/' || data[0xA0] == '.')
    return TRUE;
  // If the first byte of the date field is small (but not 0,
  // which could indicate an empty string), it's probably binary
  if (data[0x9E] >= 1 && data[0x9E] <= 31)
    return FALSE;

  // If all previous tests turned up nothing, assume it's text
  return TRUE;
}

static inline gboolean
spc_tag_is_present (guchar * data, guint length)
{
  return data[0x23] == 26;
}

static inline GDate *
spc_tag_unpack_date (guint32 packed)
{
  guint dump_year = packed / 10000;
  guint dump_month = (packed % 10000) / 100;
  guint dump_day = packed % 100;

  if (dump_month == 0)
    dump_month = 1;
  if (dump_day == 0)
    dump_day = 1;

  if (dump_year != 0)
    return g_date_new_dmy (dump_day, dump_month, dump_year);
  else
    return NULL;
}

void
spc_tag_clear (spc_tag_info * info)
{
  info->title = info->game = info->publisher = info->artist = info->album =
      info->comment = info->dumper = NULL;
  info->dump_date = NULL;
  info->time_seconds = 0;
  info->time_fade_milliseconds = 0;
  info->time_intro = 0;
  info->time_end = 0;
  info->time_loop = 0;
  info->time_fade = 0;
  info->loop_count = 0;
  info->muted = 0;
  info->disc = 0;
  info->amplification = 0;
}

void
spc_tag_get_info (guchar * data, guint length, spc_tag_info * info)
{
  spc_tag_clear (info);

  if (spc_tag_is_present (data, length)) {
    gboolean text_format = spc_tag_is_text_format (data, length);

    info->title = g_new0 (gchar, 0x21);
    info->game = g_new0 (gchar, 0x21);
    info->artist = g_new0 (gchar, 0x21);
    info->dumper = g_new0 (gchar, 0x10);
    info->comment = g_new0 (gchar, 0x32);

    strncpy (info->title, (gchar *) & data[0x2E], 32);
    strncpy (info->artist, (gchar *) & data[(text_format ? 0xB1 : 0xB0)], 32);
    strncpy (info->game, (gchar *) & data[0x4E], 32);
    strncpy (info->dumper, (gchar *) & data[0x6E], 16);
    strncpy (info->comment, (gchar *) & data[0x7E], 32);

    if (text_format) {
      gchar time[4];
      gchar fade[6];
      guint dump_year, dump_month, dump_day;

      strncpy (time, (gchar *) data + 0xA9, 3);
      strncpy (fade, (gchar *) data + 0xAC, 5);

      time[3] = fade[5] = 0;

      info->time_seconds = atoi (time);
      info->time_fade_milliseconds = atoi (fade);

      dump_year = (guint) atoi ((gchar *) data + 0x9E);
      dump_month = (guint) atoi ((gchar *) data + 0x9E + 3);
      dump_day = (guint) atoi ((gchar *) data + 0x9E + 3 + 3);

      if (dump_month == 0)
        dump_month = 1;
      if (dump_day == 0)
        dump_day = 1;
      if (dump_year != 0)
        info->dump_date = g_date_new_dmy (dump_day, dump_month, dump_year);

      info->muted = READ_INT8 (data, 0xD1);
      info->emulator = READ_INT8 (data, 0xD2);
    } else {
      info->time_seconds = READ_INT24 (data, 0xA9);
      info->time_fade_milliseconds = READ_INT32 (data, 0xAC);
      info->dump_date = spc_tag_unpack_date (READ_INT32 (data, 0x9E));
      info->muted = READ_INT8 (data, 0xD0);
      info->emulator = READ_INT8 (data, 0xD1);
    }
  }

  if (spc_tag_is_extended (data, length)) {
    guchar *chunk = data + EXTENDED_OFFSET + 8;
    guint32 chunk_size = *((guint32 *) (data + EXTENDED_OFFSET + 4));

    guchar *subchunk, *subchunk_next;

    for (subchunk = chunk; subchunk < chunk + chunk_size;
        subchunk = subchunk_next) {
      guint8 tag = READ_INT8 (subchunk, 0);
      guint8 type = READ_INT8 (subchunk, 1);
      guint16 length = READ_INT16 (subchunk, 2);
      guchar *value = subchunk + 4;

      switch (type) {
        case TYPE_LENGTH:
        {
          switch (tag) {
            case TAG_TRACK:
              info->track = READ_INT8 (subchunk, 2 + 1);
              break;
            case TAG_YEAR:
              info->year = READ_INT16 (subchunk, 2);
              break;
            case TAG_COUNT:
              info->loop_count = READ_INT8 (subchunk, 2);
              break;
            case TAG_EMULATOR:
              info->emulator = READ_INT8 (subchunk, 2);
              break;
            case TAG_DISC:
              info->disc = READ_INT8 (subchunk, 2);
              break;
            case TAG_MUTED:
              info->muted = READ_INT8 (subchunk, 2);
              break;
            default:
              break;
          }

          subchunk_next = subchunk + 4;
          break;
        }
        case TYPE_STRING:
        {
          gchar *dest;

          if (length <= 1)
            dest = NULL;
          else
            switch (tag) {
              case TAG_TITLE:
                dest = info->title = g_renew (gchar, info->title, length);
                break;
              case TAG_GAME:
                dest = info->game = g_renew (gchar, info->game, length);
                break;
              case TAG_ARTIST:
                dest = info->artist = g_renew (gchar, info->artist, length);
                break;
              case TAG_ALBUM:
                dest = info->album = g_renew (gchar, info->album, length);
                break;
              case TAG_DUMPER:
                dest = info->dumper = g_renew (gchar, info->dumper, length);
                break;
              case TAG_COMMENT:
                dest = info->comment = g_renew (gchar, info->comment, length);
                break;
              case TAG_PUBLISHER:
                dest = info->publisher =
                    g_renew (gchar, info->publisher, length);
                break;
              default:
                dest = NULL;
                break;
            }

          if (dest)
            strncpy (dest, (gchar *) value, length);

          subchunk_next = value + length;
          break;
        }
        case TYPE_INTEGER:
        {
          switch (tag) {
            case TAG_INTRO:
              info->time_intro = READ_INT32 (value, 0);
              break;
            case TAG_END:
              info->time_end = READ_INT32 (value, 0);
              break;
            case TAG_FADE:
              info->time_fade = READ_INT32 (value, 0);
              break;
            case TAG_LOOP:
              info->time_loop = READ_INT32 (value, 0);
              break;
            case TAG_DUMP_DATE:
              info->dump_date = spc_tag_unpack_date (READ_INT32 (value, 0));
              break;
            case TAG_AMP:
              info->amplification = READ_INT32 (value, 0);
              break;
            default:
              break;
          }
          subchunk_next = value + length;
          break;
        }
        default:
          subchunk_next = value + length;
          break;
      }
    }
  }

  if (info->title && !*info->title) {
    g_free (info->title);
    info->title = NULL;
  }
  if (info->game && !*info->game) {
    g_free (info->game);
    info->game = NULL;
  }
  if (info->artist && !*info->artist) {
    g_free (info->artist);
    info->artist = NULL;
  }
  if (info->album && !*info->album) {
    g_free (info->album);
    info->album = NULL;
  }
  if (info->publisher && !*info->publisher) {
    g_free (info->publisher);
    info->publisher = NULL;
  }
  if (info->comment && !*info->comment) {
    g_free (info->comment);
    info->comment = NULL;
  }
  if (info->dumper && !*info->dumper) {
    g_free (info->dumper);
    info->dumper = NULL;
  }
}

void
spc_tag_free (spc_tag_info * info)
{
  g_free (info->title);
  g_free (info->game);
  g_free (info->artist);
  g_free (info->album);
  g_free (info->publisher);
  g_free (info->comment);
  g_free (info->dumper);
  if (info->dump_date)
    g_date_free (info->dump_date);
}
