/************************************************************************************
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ************************************************************************************/
// copyright 2002 Jeremy Cowgar <jc@cowgar.com>
// copyright 2002 and 2003  L.J.Potter <ljp@llornkcor.com>

/* OPIE */
#include <opie2/odebug.h>
using namespace Opie::Core;

extern "C" {
#include "adpcm.h"
}

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/soundcard.h>

#include <errno.h>

typedef struct _waveheader {
  u_long  main_chunk; /* 'RIFF'  */
  u_long  length;     /* filelen */
  u_long  chunk_type; /* 'WAVE'  */
  u_long  sub_chunk;  /* 'fmt '                                               */
  u_long  sc_len;     /* length of sub_chunk, =16
                         (chunckSize) format len */
  u_short format;     /* should be 1 for PCM-code        (formatTag)          */

  u_short modus;      /* 1 Mono, 2 Stereo                (channels)           */
  u_long  sample_fq;  /* samples per second              (samplesPerSecond)   */
  u_long  byte_p_sec; /* avg bytes per second            (avgBytePerSecond)   */
  u_short byte_p_spl; /* samplesize; 1 or 2 bytes        (blockAlign)         */
  u_short bit_p_spl;  /* 8, 12 or 16 bit                 (bitsPerSample)      */

  u_long  data_chunk; /* 'data'      */

  u_long  data_length;/* samplecount */
} WaveHeader;

#define RIFF        0x46464952
#define WAVE        0x45564157
#define FMT         0x20746D66
#define DATA        0x61746164
#define PCM_CODE    1
#define WAVE_MONO   1
#define WAVE_STEREO 2

struct adpcm_state encoder_state;
//struct adpcm_state decoder_state;

#define WAVE_FORMAT_DVI_ADPCM (0x0011)
#define WAVE_FORMAT_PCM (0x0001)


#include "vmemo.h"

#include <opie2/otaskbarapplet.h>
#include <qpe/qpeapplication.h>
#include <qpe/config.h>

#include <qpainter.h>
#include <qmessagebox.h>

int seq = 0;

/* XPM */
static char * vmemo_xpm[] = {
  "16 16 102 2",
  "   c None",
  ".  c #60636A",
  "+  c #6E6E72",
  "@  c #68696E",
  "#  c #4D525C",
  "$  c #6B6C70",
  "%  c #E3E3E8",
  "&  c #EEEEF2",
  "*  c #EAEAEF",
  "=  c #CACAD0",
  "-  c #474A51",
  ";  c #171819",
  ">  c #9B9B9F",
  ",  c #EBEBF0",
  "'  c #F4F4F7",
  ")  c #F1F1F5",
  "!  c #DEDEE4",
  "~  c #57575C",
  "{  c #010101",
  "]  c #A2A2A6",
  "^  c #747477",
  "/  c #B5B5B8",
  "(  c #AEAEB2",
  "_  c #69696D",
  ":  c #525256",
  "<  c #181C24",
  "[  c #97979B",
  "}  c #A7A7AC",
  "|  c #B0B0B4",
  "1  c #C8C8D1",
  "2  c #75757B",
  "3  c #46464A",
  "4  c #494A4F",
  "5  c #323234",
  "6  c #909095",
  "7  c #39393B",
  "8  c #757578",
  "9  c #87878E",
  "0  c #222224",
  "a  c #414144",
  "b  c #6A6A6E",
  "c  c #020C16",
  "d  c #6B6B6F",
  "e  c #68686D",
  "f  c #5B5B60",
  "g  c #8A8A8F",
  "h  c #6B6B6E",
  "i  c #ADADB2",
  "j  c #828289",
  "k  c #3E3E41",
  "l  c #CFCFD7",
  "m  c #4C4C50",
  "n  c #000000",
  "o  c #66666A",
  "p  c #505054",
  "q  c #838388",
  "r  c #A1A1A7",
  "s  c #A9A9AE",
  "t  c #A8A8B0",
  "u  c #5E5E63",
  "v  c #3A3A3E",
  "w  c #BDBDC6",
  "x  c #59595E",
  "y  c #76767C",
  "z  c #373738",
  "A  c #717174",
  "B  c #727278",
  "C  c #1C1C1E",
  "D  c #3C3C3F",
  "E  c #ADADB6",
  "F  c #54555A",
  "G  c #8B8C94",
  "H  c #5A5A5F",
  "I  c #BBBBC3",
  "J  c #C4C4CB",
  "K  c #909098",
  "L  c #737379",
  "M  c #343437",
  "N  c #8F8F98",
  "O  c #000407",
  "P  c #2D3137",
  "Q  c #B0B1BC",
  "R  c #3B3C40",
  "S  c #6E6E74",
  "T  c #95959C",
  "U  c #74747A",
  "V  c #1D1D1E",
  "W  c #91929A",
  "X  c #42444A",
  "Y  c #22282E",
  "Z  c #B0B2BC",
  "`  c #898A90",
  " . c #65656A",
  ".. c #999AA2",
  "+. c #52535A",
  "@. c #151B21",
  "#. c #515257",
  "$. c #B5B5BE",
  "%. c #616167",
  "&. c #1A1D22",
  "*. c #000713",
  "=. c #1F1F21",
  "                                ",
  "            . + @ #             ",
  "          $ % & * = -           ",
  "        ; > , ' ) ! ~           ",
  "        { ] ^ / ( _ :           ",
  "        < [ } | 1 2 3           ",
  "      4 5 6 7 8 9 0 a b c       ",
  "    d e f g h i j 3 k l m n     ",
  "      o p q r s t u v w n       ",
  "      o x y z A B C D E n       ",
  "      F G H I J K L M N O       ",
  "      P Q R S T U V W X         ",
  "        Y Z ` b  ...+.          ",
  "          @.#.$.%.&.            ",
  "            *.B =.              ",
  "      n n n n n n n n n         "};


using namespace Opie::Ui;
VMemo::VMemo( QWidget *parent, const char *_name )
  : QWidget( parent, _name ) {
  setFixedHeight( 18 );
  setFixedWidth( 14 );

  t_timer = new QTimer( this );
  connect( t_timer, SIGNAL( timeout() ), SLOT( timerBreak() ) );

    Config vmCfg("Vmemo");
    vmCfg.setGroup("Defaults");
    int toggleKey = setToggleButton(vmCfg.readNumEntry("toggleKey", -1));
    useADPCM = vmCfg.readBoolEntry("use_ADPCM", 0);

    owarn <<"VMemo toggleKey" << toggleKey << oendl;

      systemZaurus = false;

    myChannel = new QCopChannel( "QPE/VMemo", this );

    connect( myChannel, SIGNAL(received(const QCString&,const QByteArray&)),
             this, SLOT(receive(const QCString&,const QByteArray&)) );


    if( toggleKey != -1 ) {
				owarn << "Register key " << toggleKey << "" << oendl;

				QCopEnvelope e("QPE/Launcher", "keyRegister(int,QCString,QCString)");
      //           e << 4096; // Key_Escape
      //          e << Key_F5; //4148
      e << toggleKey;
      e << QCString("QPE/VMemo");
      e << QCString("toggleRecord()");
    }
    if(toggleKey == 0)
        usingIcon = true;
    else
        usingIcon = false;
	if (!usingIcon)
			hide();
    recording = false;
}

VMemo::~VMemo() {
}

int VMemo::position()
{
    return 1;
}

void VMemo::receive( const QCString &msg, const QByteArray &data ) {
  QDataStream stream( data, IO_ReadOnly );

  if (msg == "toggleRecord()")  {
      if (recording) {
          fromToggle = true;
          stopRecording();
      }  else {
          fromToggle = true;
          startRecording();
      }
  }
}

void VMemo::paintEvent( QPaintEvent* ) {
  QPainter p(this);
  p.drawPixmap( 0, 1,( const char** )  vmemo_xpm );
}

void VMemo::mousePressEvent( QMouseEvent * /*me*/) {

		if(!recording) {
				if(!startRecording() ){
						QMessageBox::critical(0, "vmemo", "Abort Recording", "Abort Recording");
				}
		}   else {
				stopRecording();
		}
}

void VMemo::mouseReleaseEvent( QMouseEvent * ) {
}

bool VMemo::startRecording() {
  Config config( "Vmemo" );
  config.setGroup( "System" );


  odebug << "Start recording engines" << oendl;
  recording = true;

  if (openDSP() == -1)  {
			recording = false;
			return false;
  }

  config.setGroup("Defaults");

  date = TimeString::dateString( QDateTime::currentDateTime(),false,true);
  date.replace(QRegExp("'"),"");
  date.replace(QRegExp(" "),"_");
  date.replace(QRegExp(":"),"-");
  date.replace(QRegExp(","),"");

  QString fName;
  config.setGroup( "System" );
  fName = QPEApplication::documentDir() ;
  fileName = config.readEntry("RecLocation", fName);

  int s;
  s=fileName.find(':');
  if(s)
    fileName=fileName.right(fileName.length()-s-2);
  odebug << "pathname will be "+fileName << oendl;

  if( fileName.left(1).find('/') == -1)
    fileName="/"+fileName;
  if( fileName.right(1).find('/') == -1)
    fileName+="/";
  fName = "vm_"+ date + ".wav";

  fileName += fName;
  odebug << "filename is " + fileName << oendl;

  useAlerts = config.readBoolEntry("Alert",1);
  if(useAlerts) {
    msgLabel = new QLabel( 0, "alertLabel" );
    msgLabel->setText( tr("<B><P><font size=+2>VMemo-Recording</font></B><p>%1</p>").arg("vm_"+ date));
    msgLabel->show();
  }
	
  // open tmp file here
  char *tmpFilePath = 0;
  char *tmpDir = getenv("TMPDIR");
  if (tmpDir && *tmpDir != '\0') {
    tmpFilePath = new char[strlen(tmpDir) + strlen("/vmemo-wav-XXXXXX") + 1];
    strcpy(tmpFilePath, tmpDir);
    free(tmpDir);
  } else {
    tmpFilePath = new char[strlen("/tmp/vmemo-wav-XXXXXX") + 1];
    strcpy(tmpFilePath, "/tmp");
  }
  strcat(tmpFilePath, "/vmemo-wav-XXXXXX");
  mode_t currUmask = umask(S_IRWXO | S_IRWXG);
  int tmpFd = mkstemp(tmpFilePath);
  umask(currUmask);
  if (tmpFd == -1) {
    owarn << "Could not open temp file with template " << tmpFilePath
          << oendl;
    delete [] tmpFilePath;
    return false;
  } else
    odebug << "Opened temp file " << tmpFilePath << "" << oendl;

  close(tmpFd);

  if(openWAV(tmpFilePath ) == -1)  {

    QString err("Could not open the temp file\n");
    err += fileName;
    QMessageBox::critical(0, "vmemo", err, "Abort");
    ::close(dsp);
    return false;
  }
  if( record() ) {

    if( fileName.find(".wav",0,true) == -1)
        fileName += ".wav";

    int retVal = rename(tmpFilePath, fileName.local8Bit());
    if (retVal == -1) {
	owarn << "Could not move " << tmpFilePath << " to " << fileName
              << oendl;
	delete [] tmpFilePath;
	return false;
    }
    delete [] tmpFilePath;

    QArray<int> cats(1);
    cats[0] = config.readNumEntry("Category", 0);

    QString dlName("vm_");
    dlName += date;
    DocLnk l;
    l.setFile(fileName);
    l.setName(dlName);
    l.setType("audio/x-wav");
    l.setCategories(cats);
    l.writeLink();
    return true;
  } else
      return false;

}

void VMemo::stopRecording() {
//    show();
    odebug << "Stopped recording" << oendl;
    recording = false;
    if(useAlerts) {
        msgLabel->close();
        msgLabel=0;
        delete msgLabel;
    }
    t_timer->stop();
    Config cfg("Vmemo");
    cfg.setGroup("Defaults");
//     if( cfg.readNumEntry("hideIcon",0) == 1 )
//         hide();
}

int VMemo::openDSP() {
  Config cfg("Vmemo");
  cfg.setGroup("Record");

  speed = cfg.readNumEntry("SampleRate", 22050);
  channels = cfg.readNumEntry("Stereo", 1) ? 2 : 1; // 1 = stereo(2), 0 = mono(1)
  if (cfg.readNumEntry("SixteenBit", 1)==1)  {
    format = AFMT_S16_LE;
    resolution = 16;
  } else {
    format = AFMT_U8;
    resolution = 8;
  }

  odebug << "samplerate: " << speed << ", channels " << channels << ", resolution " << resolution << "" << oendl;

  if(systemZaurus) {
    dsp = open("/dev/dsp1", O_RDONLY); //Zaurus needs /dev/dsp1
    channels=1; //zaurus has one input channel
  }  else {
#ifdef QT_QWS_DEVFS
    dsp = open("/dev/sound/dsp", O_RDONLY);
#else
    dsp = open("/dev/dsp", O_RDONLY);
#endif
  }

  if (dsp == -1)  {
      msgLabel->close();
      msgLabel=0;
      delete msgLabel;

      perror("open(\"/dev/dsp\")");
      errorMsg="open(\"/dev/dsp\")\n "+(QString)strerror(errno);
      QMessageBox::critical(0, "vmemo", errorMsg, "Abort");
      return -1;
  }

  if(ioctl(dsp, SNDCTL_DSP_SETFMT , &format)==-1)  {
    perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
//    return -1;
  }
  if(ioctl(dsp, SNDCTL_DSP_CHANNELS , &channels)==-1)  {
    perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
//    return -1;
  }
  if(ioctl(dsp, SNDCTL_DSP_SPEED , &speed)==-1)  {
    perror("ioctl(\"SNDCTL_DSP_SPEED\")");
//    return -1;
  }
  if(ioctl(dsp, SOUND_PCM_READ_RATE , &rate)==-1)  {
    perror("ioctl(\"SOUND_PCM_READ_RATE\")");
//    return -1;
  }

  QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false; //mute

  return 1;
}

int VMemo::openWAV(const char *filename) {
  track.setName(filename);
  if(!track.open(IO_WriteOnly|IO_Truncate|IO_Raw)) {
    errorMsg=filename;
    return -1;
  }

  wav=track.handle();
    Config vmCfg("Vmemo");
    vmCfg.setGroup("Defaults");
  useADPCM = vmCfg.readBoolEntry("use_ADPCM", 0);

  WaveHeader wh;

  wh.main_chunk = RIFF;
  wh.length=0;
  wh.chunk_type = WAVE;
  wh.sub_chunk  = FMT;
  wh.sc_len     = 16;
  if(useADPCM)
      wh.format     = WAVE_FORMAT_DVI_ADPCM;//PCM_CODE;
  else
      wh.format     = PCM_CODE;
  wh.modus      = channels;
  wh.sample_fq  = speed;
  wh.byte_p_sec = speed * channels *  resolution/8;
  wh.byte_p_spl = channels * (resolution / 8);
  wh.bit_p_spl  = resolution;
  wh.data_chunk = DATA;
  wh.data_length= 0;
  //    odebug << "Write header channels " << wh.modus << ", speed " << wh.sample_fq << ", b/s "
  //           << wh.byte_p_sec << ", blockalign " << wh.byte_p_spl << ", bitrate " << wh.bit_p_spl << oendl;
  write (wav, &wh, sizeof(WaveHeader));

  return 1;
}

bool VMemo::record() {
		length = 0;
		int bytesWritten = 0;
		int result = 0;
		int value = 0;

		QString msg;
		msg.sprintf("Recording format %d", format);
		odebug << msg << oendl;

		Config config("Vmemo");
		config.setGroup("Record");
		int sRate = config.readNumEntry("SizeLimit", 30);
		odebug << "VMEMO rate" << sRate << oendl;

		if(sRate > 0) {
				t_timer->start( sRate * 1000+1000, true);
		}

		msg.sprintf("Recording format other");
		odebug << msg << oendl;

    config.setGroup("Defaults");
    useADPCM = config.readBoolEntry("use_ADPCM", 0);

    int bufsize = config.readNumEntry("BufferSize",1024);
    unsigned short sound[bufsize]; //, monoBuffer[bufsize];
    char abuf[bufsize / 2];
    short sbuf[bufsize];
		odebug << "ready to record"<< oendl;
		if(useADPCM) {
				odebug << "usr ADPCM" << oendl;

				while(recording) {
						result = ::read(dsp, sbuf, bufsize); // adpcm read
						if( result <= 0) {
								perror("recording error ");
								QMessageBox::message(tr("Note"),tr("error recording"));
								recording = false;
								break;
								return false;
						}
						adpcm_coder( sbuf, abuf, result/2, &encoder_state);
						bytesWritten = ::write(wav, abuf, result/4); // adpcm write
						length += bytesWritten;

						if(length < 0) {
								recording = false;
								perror("dev/dsp's is a lookin' messy");
								QMessageBox::message("Vmemo","Error writing to file\n"+ fileName);
								break;
								return false;
						}
						printf("%d\r", length);
						fflush(stdout);
						qApp->processEvents();
				}
		} else {
				odebug << "use regular wav" << oendl;
				while(recording) {
						result = ::read(dsp, sound, bufsize); // read
						if( result <= 0) {
								perror("recording error ");
								QMessageBox::message(tr("Note"),tr("error recording"));
								recording = false;
								break;
								return false;
						}

						bytesWritten = ::write(wav, sound, result); // write
						length += bytesWritten;

						if(length < 0) {
								recording = false;
								perror("dev/dsp's is a lookin' messy");
								QMessageBox::message("Vmemo","Error writing to file\n"+ fileName);
								break;
								return false;
						}
//          printf("%d\r", length);
//          fflush(stdout);
						qApp->processEvents();
				}
		}
		owarn << "file has length of " << length << " lasting " << (( length / speed) / channels) / 2  << " seconds" << oendl;

		value = length + 36;

		lseek(wav, 4, SEEK_SET);
		write(wav, &value, 4);
		lseek(wav, 40, SEEK_SET);

		write(wav, &length, 4);

		track.close();

		if( ioctl( dsp, SNDCTL_DSP_RESET,0) == -1)
				perror("ioctl(\"SNDCTL_DSP_RESET\")");

		::close(dsp);

		Config cfgO("OpieRec");
		cfgO.setGroup("Sounds");

		int nFiles = cfgO.readNumEntry( "NumberofFiles",0);

		QString currentFileName = fileName;
		QString currentFile = "vm_"+ date;

		float numberOfRecordedSeconds = (float) length / (float)speed * (float)2;

		cfgO.writeEntry( "NumberofFiles", nFiles + 1);
		cfgO.writeEntry( QString::number( nFiles + 1), currentFile);
		cfgO.writeEntry( currentFile, currentFileName);

		QString time;
		time.sprintf("%.2f", numberOfRecordedSeconds);
		cfgO.writeEntry( currentFileName, time );
      //      odebug << "writing config numberOfRecordedSeconds "+time << oendl;

		cfgO.write();

		odebug << "done recording "+fileName << oendl;

		Config cfg("qpe");
		cfg.setGroup("Volume");
		QString foo = cfg.readEntry("Mute","true");
		if(foo.find("true",0,true) != -1)
				QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << true; //mute
		return true;
}

int VMemo::setToggleButton(int tog) {

  for( int i=0; i < 10;i++) {
    switch (tog) {
    case 0:
      return -1;
      break;
    case 1:
      return 0;
      break;
    case 2:
        return Key_F24; //was Escape
      break;
    case 3:
      return Key_Space;
      break;
    case 4:
      return Key_F12;
      break;
    case 5:
      return Key_F9;
      break;
    case 6:
      return Key_F10;
      break;
    case 7:
      return Key_F11;
      break;
    case 8:
      return Key_F13;
      break;
    };
  }
  return -1;
}

void VMemo::timerBreak() {
  //stop
    stopRecording();
  QMessageBox::message("Vmemo","Vmemo recording has ended");
}


EXPORT_OPIE_APPLET_v1( VMemo )