#include "tsio_aiff.h"

#include "tmachine.h"

#include "tsound_t.h"

#include "tsystem.h"

#include "tfilepath_io.h"

#include "tsioutils.h"

#include <math.h></math.h>

#define DEFAULT_OFFSET 0

#define DEFAULT_BLOCKSIZE 0

#define AIFF_NBYTE 4

#define COMM_NBYTE 24

#define OFFSETBLOCSIZE_NBYTE 8

#define SSND_PREDATA_NBYTE 16

#if !defined(TNZ_LITTLE_ENDIAN)

TNZ_LITTLE_ENDIAN undefined !!

#endif

    using namespace std;

TUINT32 convertToLong(UCHAR *buffer);

void storeFloat(unsigned char *buffer, TUINT32 value);

//====================================================================

// TAIFFChunk: classe base per i vari chunk

class TAIFFChunk {

public:

  string m_name;

  TINT32 m_length;  // lunghezza del chunk in byte

  TAIFFChunk(string name, TINT32 length) : m_name(name), m_length(length) {}

  virtual ~TAIFFChunk() {}

  virtual bool read(ifstream &is) {

    skip(is);

    return true;

  }

  void skip(ifstream &is) { is.seekg((TINT32)is.tellg() + (TINT32)m_length); }

  static bool readHeader(ifstream &is, string &name, TINT32 &length) {

    char cName[5];

    TINT32 len;

    is.read((char *)&cName, 4);

    if (is.fail()) return false;

    cName[4] = '\0';

    is.read((char *)&len, sizeof(len));

    if (TNZ_LITTLE_ENDIAN) len = swapTINT32(len);

    if (is.fail()) return false;

    name   = string(cName);

    length = len;

    return true;

  }

};

//====================================================================

//  COMM Chunk: Chunk contenente le informazioni sulla traccia

class TCOMMChunk final : public TAIFFChunk {

public:

  USHORT m_chans;    // numero di canali

  TUINT32 m_frames;  // numero di campioni

  USHORT m_bitPerSample;

  TUINT32 m_sampleRate;

  TCOMMChunk(string name, TINT32 length) : TAIFFChunk(name, length) {}

  bool read(ifstream &is) override {

    long pos = is.tellg();

    is.read((char *)&m_chans, sizeof(m_chans));

    is.read((char *)&m_frames, sizeof(m_frames));

    is.read((char *)&m_bitPerSample, sizeof(m_bitPerSample));

    if (TNZ_LITTLE_ENDIAN) {

      m_chans        = swapUshort(m_chans);

      m_frames       = swapTINT32(m_frames);

      m_bitPerSample = swapUshort(m_bitPerSample);

    }

    UCHAR sampleRateBuffer[10];  // sample rate come letto dallo stream

    memset(sampleRateBuffer, 0, 10);

    is.read((char *)&sampleRateBuffer, sizeof(sampleRateBuffer));

    m_sampleRate = convertToLong(sampleRateBuffer);

    is.seekg(pos + (long)m_length, is.beg);

    return true;

  }

  bool write(ofstream &os) {

    TINT32 length       = m_length;

    USHORT chans        = m_chans;

    TUINT32 frames      = m_frames;

    USHORT bitPerSample = m_bitPerSample;

    TUINT32 sampleRate  = m_sampleRate;

    if (TNZ_LITTLE_ENDIAN) {

      length       = swapTINT32(length);

      chans        = swapUshort(chans);

      frames       = swapTINT32(frames);

      bitPerSample = swapUshort(bitPerSample);

    }

    UCHAR sampleRateBuffer[10];

    storeFloat(sampleRateBuffer, sampleRate);

    // assert(convertToLong(sampleRateBuffer) == sampleRate);

    os.write((char *)"COMM", 4);

    os.write((char *)&length, sizeof(TINT32));

    os.write((char *)&chans, sizeof(short));

    os.write((char *)&frames, sizeof(TINT32));

    os.write((char *)&bitPerSample, sizeof(short));

    os.write((char *)&sampleRateBuffer, sizeof(sampleRateBuffer));

    return true;

  }

  virtual void print(ostream &os) const {

    os << "canali   = '" << m_chans << endl;

    os << "frames   = '" << (unsigned int)m_frames << endl;

    os << "bitxsam  = '" << m_bitPerSample << endl;

    os << "rate	    = '" << (unsigned int)m_sampleRate << endl;

  }

};

//--------------------------------------------------------------------

static ostream &operator<<(ostream &os, const TCOMMChunk &commChunk) {

  commChunk.print(os);

  return os;

}

//====================================================================

//  SSND Chunk: Chunk contenente i campioni della traccia

class TSSNDChunk final : public TAIFFChunk {

public:

  TUINT32 m_offset;  // dall'inizio dei sample frames tra i wavedata

  TUINT32 m_blockSize;

  std::unique_ptr<uchar[]> m_waveData;</uchar[]>

  TSSNDChunk(string name, TINT32 length) : TAIFFChunk(name, length) {}

  bool read(ifstream &is) override {

    is.read((char *)&m_offset, sizeof(m_offset));

    is.read((char *)&m_blockSize, sizeof(m_blockSize));

    if (TNZ_LITTLE_ENDIAN) {

      m_offset    = swapTINT32(m_offset);

      m_blockSize = swapTINT32(m_blockSize);

    }

    // alloca il buffer dei campioni

    m_waveData.reset(new UCHAR[m_length - OFFSETBLOCSIZE_NBYTE]);

    if (!m_waveData) cout << " ERRORE " << endl;

    is.read((char *)m_waveData.get(), m_length - OFFSETBLOCSIZE_NBYTE);

    return true;

  }

  bool write(ofstream &os) {

    TINT32 length     = m_length;

    TUINT32 offset    = m_offset;

    TUINT32 blockSize = m_blockSize;

    if (TNZ_LITTLE_ENDIAN) {

      length    = swapTINT32(length);

      offset    = swapTINT32(offset);

      blockSize = swapTINT32(blockSize);

    }

    os.write((char *)"SSND", 4);

    os.write((char *)&length, sizeof(TINT32));

    os.write((char *)&offset, sizeof(TINT32));

    os.write((char *)&blockSize, sizeof(TINT32));

    os.write((char *)m_waveData.get(), m_length - OFFSETBLOCSIZE_NBYTE);

    return true;

  }

};

//--------------------------------------------------------------------

static ostream &operator<<(ostream &os, const TSSNDChunk &ssndChunk) {

  os << "name      = '" << ssndChunk.m_name << endl;

  os << "length    = '" << ssndChunk.m_length << endl;

  os << "offset    = '" << (unsigned int)ssndChunk.m_offset << endl;

  os << "blocksize = '" << (unsigned int)ssndChunk.m_blockSize << endl;

#ifdef PRINT_SAMPLES

  os << " samples" << endl;

  for (int i = 0; i < ((ssndChunk.m_length - 8) / 2); ++i)

    os << i << ((short *)*(ssndChunk.m_waveData + i)) << dec << endl;

#endif

  return os;

}

//==========================================================

static void flipLong(unsigned char *ptrc) {

  unsigned char val;

  val         = *(ptrc);

  *(ptrc)     = *(ptrc + 3);

  *(ptrc + 3) = val;

  ptrc += 1;

  val         = *(ptrc);

  *(ptrc)     = *(ptrc + 1);

  *(ptrc + 1) = val;

}

//--------------------------------------------------------------------

static TUINT32 fetchLong(TUINT32 *ptrl) { return (*ptrl); }

//--------------------------------------------------------------------

TUINT32 convertToLong(UCHAR *buffer) {

  TUINT32 mantissa;

  TUINT32 last = 0;

  UCHAR exp;

  if (TNZ_LITTLE_ENDIAN) {

    // flipLong((TUINT32 *) (buffer+2));

    flipLong(buffer + 2);

  }

  mantissa = *((TUINT32 *)(buffer + 2));

  exp      = 30 - *(buffer + 1);

  while (exp--) {

    last = mantissa;

    mantissa >>= 1;

  }

  if (last & 0x00000001) mantissa++;

  return (mantissa);

}

//--------------------------------------------------------------------

static void storeLong(TUINT32 val, TUINT32 *ptr) { *ptr = val; }

//--------------------------------------------------------------------

void storeFloat(unsigned char *buffer, TUINT32 value) {

  TUINT32 exp;

  unsigned char i;

  memset(buffer, 0, 10);

  exp = value;

  exp >>= 1;

  for (i = 0; i < 32; i++) {

    exp >>= 1;

    if (!exp) break;

  }

  *(buffer + 1) = i;

  for (i = 32; i; i--) {

    if (value & 0x80000000) break;

    value <<= 1;

  }

  *((TUINT32 *)(buffer + 2)) = value;

  buffer[0] = 0x40;

  if (TNZ_LITTLE_ENDIAN) {

    // flipLong((TUINT32*) (buffer+2));

    flipLong(buffer + 2);

  }

}

//==============================================================================

TSoundTrackReaderAiff::TSoundTrackReaderAiff(const TFilePath &fp)

    : TSoundTrackReader(fp) {}

//------------------------------------------------------------------------------

TSoundTrackP TSoundTrackReaderAiff::load() {

  char ckID[5];

  char formType[5];

  TINT32 ckSize;

  Tifstream is(m_path);

  if (!is)

    throw TException(L"Unable to load the AIFF file " + m_path.getWideString() +

                     L" : doesn't exist");

  // legge il chunk ID

  is.read((char *)&ckID, sizeof(ckID) - 1);

  ckID[4] = '\0';

  // legge il chunk Size

  is.read((char *)&ckSize, sizeof(ckSize));

  if (TNZ_LITTLE_ENDIAN) ckSize = swapTINT32(ckSize);

  // legge il formType

  is.read((char *)&formType, sizeof(formType) - 1);

  formType[4] = '\0';

  // il formType DEVE essere uguale a "AIFF"

  if ((string(formType, 4) != "AIFF") && (string(formType, 4) != "AIFC"))

    throw TException("The AIFF file doesn't contain the AIFF form");

  TCOMMChunk *commChunk = 0;

  TSSNDChunk *ssndChunk = 0;

  while (!is.eof()) {

    string name;

    TINT32 length;

    bool ret = TAIFFChunk::readHeader(is, name, length);

    if (!ret) break;

    // legge solo i chunk che ci interessano, ossia COMM e SSND

    if (name == "COMM") {

      // legge i dati del chunk COMM

      commChunk = new TCOMMChunk("COMM", length);

      commChunk->read(is);

      // considera il byte di pad alla fine del chunk nel caso

      // in cui la lunghezza di questi e' dispari

      if (length % 2) is.seekg((TINT32)is.tellg() + 1);

    } else if (name == "SSND") {

      // legge i dati del chunk SSND

      ssndChunk = new TSSNDChunk("SSND", length);

      ssndChunk->read(is);

      // considera il byte di pad alla fine del chunk nel caso

      // in cui la lunghezza di questi e' dispari

      if (length % 2) is.seekg((TINT32)is.tellg() + 1);

    } else {

      // spostati nello stream di un numero di byte pari a length

      if (!(length % 2))

        is.seekg((TINT32)is.tellg() + length);

      else

        is.seekg((TINT32)is.tellg() + (TINT32)length + 1);

    }

  }

  TSoundTrack *track = 0;

  if (commChunk && ssndChunk) {

    if (commChunk->m_chans < 1)

      throw TException("Invalid channels number in sound file");

    if (commChunk->m_chans > 2)

      throw TException("Unsupported channels number in sound file");

    switch (commChunk->m_bitPerSample) {

    case 8:

      if (commChunk->m_chans == 1)

        track = new TSoundTrackMono8Signed(commChunk->m_sampleRate, 1,

                                           (TINT32)commChunk->m_frames);

      else

        track = new TSoundTrackStereo8Signed(commChunk->m_sampleRate, 2,

                                             (TINT32)commChunk->m_frames);

      memcpy((void *)track->getRawData(),

             (void *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

             commChunk->m_frames * commChunk->m_chans);

      break;

    case 16:

      if (commChunk->m_chans == 1)

        track = new TSoundTrackMono16(commChunk->m_sampleRate, 1,

                                      (TINT32)commChunk->m_frames);

      else  // due canali

        track = new TSoundTrackStereo16(commChunk->m_sampleRate, 2,

                                        (TINT32)commChunk->m_frames);

      if (!TNZ_LITTLE_ENDIAN)

        memcpy((void *)track->getRawData(),

               (void *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

               commChunk->m_frames * track->getSampleSize());

      else

        swapAndCopy16Bits(

            (short *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

            (short *)track->getRawData(),

            (TINT32)(commChunk->m_frames * commChunk->m_chans));

      break;

    case 24:

      if (commChunk->m_chans == 1)

        track = new TSoundTrackMono24(commChunk->m_sampleRate, 1,

                                      (TINT32)commChunk->m_frames);

      else  // due canali

        track = new TSoundTrackStereo24(commChunk->m_sampleRate, 2,

                                        (TINT32)commChunk->m_frames);

       if (!TNZ_LITTLE_ENDIAN)

        memcpy((void *)track->getRawData(),

               (void *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

               commChunk->m_frames * track->getSampleSize());

      else

         swapAndCopy24Bits(

             (void *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

             (void *)track->getRawData(),

             (TINT32)(commChunk->m_frames * commChunk->m_chans));

       break;

    case 32:

      if (commChunk->m_chans == 1)

        track = new TSoundTrackMono32Float(commChunk->m_sampleRate, 1,

                                           (TINT32)commChunk->m_frames);

      else  // due canali

        track = new TSoundTrackStereo32Float(commChunk->m_sampleRate, 2,

                                             (TINT32)commChunk->m_frames);

       if (!TNZ_LITTLE_ENDIAN)

        memcpy((void *)track->getRawData(),

               (void *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

               commChunk->m_frames * track->getSampleSize());

      else

         swapAndCopy32Bits(

             (TINT32 *)(ssndChunk->m_waveData.get() + ssndChunk->m_offset),

             (TINT32 *)track->getRawData(),

             (TINT32)(commChunk->m_frames * commChunk->m_chans));

       break;

    }

    if (commChunk) delete commChunk;

    if (ssndChunk) delete ssndChunk;

  }

  return track;

}

//==============================================================================

TSoundTrackWriterAiff::TSoundTrackWriterAiff(const TFilePath &fp)

    : TSoundTrackWriter(fp) {}

//------------------------------------------------------------------------------

bool TSoundTrackWriterAiff::save(const TSoundTrackP &st) {

  if (!st)

    throw TException(L"Unable to save the soundtrack: " +

                     m_path.getWideString());

  TSoundTrackP sndtrack;

  if (st->getBitPerSample() == 8 && !st->isSampleSigned())

    throw TException(

        "The format (8 bit unsigned) is incompatible with AIFF file");

  else

    sndtrack = st;

  TINT32 soundDataCount =

      (TINT32)(sndtrack->getSampleCount() * sndtrack->getChannelCount() *

               tceil(sndtrack->getBitPerSample() / 8));

  TINT32 postHeadData =

      AIFF_NBYTE + COMM_NBYTE + SSND_PREDATA_NBYTE + soundDataCount;

  TFileStatus fs(m_path);

  if (fs.doesExist() && !fs.isWritable())

    throw TException(L"Unable to save the soundtrack: " +

                     m_path.getWideString() + L" is read-only");

  Tofstream os(m_path);

  TCOMMChunk commChunk("COMM", 18);

  commChunk.m_chans  = sndtrack->getChannelCount();

  commChunk.m_frames = sndtrack->getSampleCount();

  commChunk.m_bitPerSample =

      sndtrack->getBitPerSample();  // assumendo che non ci siano 12 bit

  commChunk.m_sampleRate = sndtrack->getSampleRate();

  TSSNDChunk ssndChunk("SSND", soundDataCount + OFFSETBLOCSIZE_NBYTE);

  ssndChunk.m_offset    = DEFAULT_OFFSET;

  ssndChunk.m_blockSize = DEFAULT_BLOCKSIZE;

  std::unique_ptr<uchar[]> waveData(new UCHAR[soundDataCount]);</uchar[]>

  if (TNZ_LITTLE_ENDIAN) {

    postHeadData = swapTINT32(postHeadData);

    switch (commChunk.m_bitPerSample) {

    case 16:

      swapAndCopy16Bits((short *)sndtrack->getRawData(),

                        (short *)waveData.get(),

                        (TINT32)(commChunk.m_frames * commChunk.m_chans));

      break;

    case 24:

      swapAndCopy24Bits((void *)sndtrack->getRawData(), (void *)waveData.get(),

                        (TINT32)(commChunk.m_frames * commChunk.m_chans));

      break;

    case 32:

      swapAndCopy32Bits((TINT32 *)sndtrack->getRawData(),

                        (TINT32 *)waveData.get(),

                        (TINT32)(commChunk.m_frames * commChunk.m_chans));

      break;

    default:

      memcpy((void *)waveData.get(), (void *)sndtrack->getRawData(),

             soundDataCount);

      break;

    }

  } else {

    memcpy((void *)waveData.get(), (void *)sndtrack->getRawData(),

           soundDataCount);

  }

  ssndChunk.m_waveData = std::move(waveData);

  os.write("FORM", 4);

  os.write((char *)&postHeadData, sizeof(TINT32));

  os.write("AIFF", 4);

  commChunk.write(os);

  ssndChunk.write(os);

  return true;

}