/* Copyright (C) 2015 Alexander Schmidt <alex@treefish.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>. 
 */

#include <iostream>
#include <iomanip>
#include <iostream>
#include <taglib/fileref.h>
#include <taglib/tag.h>
#include <taglib/tpropertymap.h>
#include <taglib/tstringlist.h>
#include <getopt.h>
#include <vector>
#include <sstream>

using namespace std;

enum action {LIST, REPLACE, INSERT, ERASE, AUDIO};
typedef pair<action,string> actionpair;
typedef vector<actionpair> actionqueue;
typedef pair<TagLib::String,TagLib::StringList> keyandvalues;

keyandvalues toKeyAndValues (const string &rawstring)
{
  stringstream tmpss;
  TagLib::String key;
  TagLib::StringList values;
  int isplit=0;
  
  for (int ipos=0; ipos < rawstring.length(); ipos++) {
    if ( rawstring[ipos] == '\\' ) {
      switch (rawstring[ipos+1]) {
      case '\\':
	tmpss << '\\';
	break;
      case '=':
	tmpss << '=';
	break;
      default:
	tmpss << '\\' << rawstring[ipos+1];
	break;
      }
      ipos++;
    }
    else
      if ( rawstring[ipos] == '=' ) {
	if ( isplit == 0 ) 
	  key = tmpss.str();
	else
	  values.append(tmpss.str());
	isplit++;
	tmpss.str("");
      }
      else
	tmpss << rawstring[ipos];
  }

  if (isplit==0)
    key = tmpss.str();
  else
    values.append(tmpss.str());
  
  return make_pair(key, values);
}

void action_eraseTag (TagLib::PropertyMap &propmap, const string &key)
{
  propmap.erase(key);
}

void action_replaceTag (TagLib::PropertyMap &propmap, const keyandvalues &keyAndValues)
{
  propmap.replace(keyAndValues.first, keyAndValues.second);
}

void action_insertTag (TagLib::PropertyMap &propmap, const keyandvalues &keyAndValues)
{
  propmap.insert(keyAndValues.first, keyAndValues.second);
}

int action_printTags (const TagLib::FileRef f, TagLib::PropertyMap &propmap)
{
  if(f.tag()) {
    unsigned int longest = 0;
    for(TagLib::PropertyMap::ConstIterator i = propmap.begin(); i != propmap.end(); ++i) {
      if (i->first.size() > longest) {
	longest = i->first.size();
      }
    }
    cout << " \\_____/ TAGS \\_____ _ _ _" << endl;
    for(TagLib::PropertyMap::ConstIterator i = propmap.begin(); i != propmap.end(); ++i) {
      for(TagLib::StringList::ConstIterator j = i->second.begin(); j != i->second.end(); ++j) {
	cout << i->first << "=" << *j << endl;
      }
    }
    return 0;
  }
  else
    return 1;
}

int action_printAudio (const TagLib::FileRef f)
{
  if(f.audioProperties()) {
    TagLib::AudioProperties *properties = f.audioProperties();
    int seconds = properties->length() % 60;
    int minutes = (properties->length() - seconds) / 60;
    cout << " \\_____/ AUDIO PROPERTIES \\_____ _ _ _" << endl;
    cout << "BITRATE=" << properties->bitrate() << endl;
    cout << "SAMPLERATE=" << properties->sampleRate() << endl;
    cout << "CHANNELS=" << properties->channels() << endl;
    cout << "LENGTH=" << minutes << ":" << setfill('0') << setw(2) << seconds << endl;
    return 0;
  }
  else
    return 1;
}

void printHelp ()
{  
  cout <<
    "Usage: usetaglib [ACTION]... [FILE]...\n"    
    "Read and edit meta-data of audio formats supported by taglib.\n"
    "Multiple ACTIONS and FILES may be given in arbitrary order.\n"
    "\n"
    "-h, --help      show help\n"
    "-H, --longhelp  show long help\n"
    "\n"
    "ACTIONS\n"
    "  If multiple actions are specified they are executed in given order.\n"
    "\n"
    "  -l, --list                    list all tags (implicit if no action given)\n"
    "  -a, --audio                   show audio properties\n"
    "  -e, --erase=TAGNAME           erase tag TAGNAME\n"
    "  -r, --replace=TAGNAME=TAGVAL  replace tag TAGNAME with value TAGVAL\n"
    "  -i, --insert=TAGNAME=TAGVAL   insert tag TAGNAME with value TAGVAL\n";
}

void printExtraHelp ()
{
  cout <<
    "\n"
    "TAGNAME\n"
    "  TAGNAME is a media format independent id encoding the type of a tag.\n"
    "  Note that also in --list output, format specific tag ids are translated\n"
    "  to unified TAGNAMES.\n"
    "\n"
    "  Some \"well-known\" tags you might want to use are:\n"
    "  TITLE ALBUM ARTIST ALBUMARTIST SUBTITLE TRACKNUMBER DISCNUMBER DATE\n"
    "  ORIGINALDATE GENRE COMMENT TITLESORT ALBUMSORT ARTISTSORT\n"
    "  ALBUMARTISTSORT COMPOSER LYRICIST CONDUCTOR REMIXER PERFORMER ISRC ASIN\n"
    "  BPM COPYRIGHT ENCODEDBY MOOD COMMENT MEDIA LABEL CATALOGNUMBER BARCODE\n"
    "\n"
    "TAGVAL\n"
    "  TAGVAL has to be either a single string or a list of strings separated\n"
    "  by equal signs (=). If a list is given, multiple tags of type TAGNAME\n"
    "  will be created and set to the respective values given by the list.\n"
    "  Note that equal signs have to be escaped with a leading backslash (\\=),\n"
    "  if they shall not be interpreted as list separators.\n"
    "\n"
    "EXAMPLES\n"
    "  usetaglib file.ogg\n"
    "  usetaglib -e ALBUM file.flac\n"
    "  usetaglib -r \"ALBUM=New Album\" -i ARTIST=Horst=Hubert file.mp3\n"
    "  usetaglib -r ARTIST=Horst -l file1.ogg file2.mp3\n"
    "  usetaglib -i \"ALBUMARTIST=Horst und Hubert\" file.ogg\n"
    "  usetaglib --insert=\"ALBUMARTIST=Horst und Hubert\" file.ogg\n"
    "  usetaglib --replace='ARTIST=This Band \\= Great' file.ogg\n";
}
  
int main(int argc, char *argv[])
{
  int c;
  actionqueue requestedActions;
  
  while (1)
    {
      static struct option long_options[] =
        {
	  {"help",      no_argument,       0, 'h'},
 	  {"longhelp",  no_argument,       0, 'H'},
          {"list",      no_argument,       0, 'l'},
	  {"audio",     no_argument,       0, 'a'},
          {"insert",    required_argument, 0, 'i'},
          {"erase",     required_argument, 0, 'e'},
          {"replace",   required_argument, 0, 'r'},
          {0, 0, 0, 0}
        };

      int option_index = 0;      
      c = getopt_long (argc, argv, "hHlai:e:r:",
                       long_options, &option_index);

      if (c == -1)
        break;

      switch (c)
        {
        case 0:
          if (long_options[option_index].flag != 0)
            break;
	case 'h':
	  printHelp();
	  return 0;
          break;
	case 'H':
	  printHelp();
	  printExtraHelp();
	  return 0;
          break;
        case 'l':
	  requestedActions.push_back( make_pair(LIST, "") );
          break;
	case 'a':
	  requestedActions.push_back( make_pair(AUDIO, "") );
          break;
        case 'i':
	  requestedActions.push_back( make_pair(INSERT, optarg) );
          break;
        case 'e':
	  requestedActions.push_back( make_pair(ERASE, optarg) );
          break;
        case 'r':
	  requestedActions.push_back( make_pair(REPLACE, optarg) );
          break;
        case '?':
          break;
        default:
          abort ();
        }
    }

  if ( optind == argc ) {
    printHelp();
    return 0;
  }
  
  if (requestedActions.size() == 0)
    requestedActions.push_back( make_pair(LIST, "") );
        
  for(int i = optind; i < argc; i++) {
    cout << " _________________________________________ _ _ _" << endl;
    cout << "/" << endl;
    cout << "  " << argv[i] << endl;
    cout << "\\_________________________________________ _ _ _" << endl;
    
    TagLib::FileRef f(argv[i]);

    if(f.isNull())
      continue;

    TagLib::PropertyMap propmap = f.file()->properties();    
    bool FCHANGED = false;
    
    for (actionqueue::iterator actit = requestedActions.begin(); actit != requestedActions.end(); ++actit) {
      switch (actit->first) {
      case LIST:
	action_printTags(f, propmap);
	break;
      case AUDIO:
	action_printAudio(f);
	break;
      case ERASE:
	action_eraseTag(propmap, actit->second);
	FCHANGED = true;
	break;
      case REPLACE:
	action_replaceTag(propmap, toKeyAndValues(actit->second));
	FCHANGED = true;
	break;
      case INSERT:
	action_insertTag(propmap, toKeyAndValues(actit->second));
	FCHANGED = true;
	break;
      }
    }

    if (FCHANGED) {
      f.file()->setProperties(propmap);
      f.file()->save();
    }
  }
  
  return 0;
}