#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <fstream>

//#define NOCASE
/*
 * bibsorter
 *
 * Reads a bibtex file with multiple entries and sorts them and writes back all unique entries. 
 * You may change the priority list to change the rules to reject double entries. bibsorter 
 * prefers labels with lower case.
 * E.g. 'book' comes before 'unpublished' and 'Wind95' before 'WIND95'


CC -LANG:std -O2 bibsorter.C -o bibsorter
g++ -O2 bibsorter.C -o bibsorter
 */

void usage(char* name);
const std::string copyright="BiBTeX Sorter, (C) 2002, matthey@ii.uib.no, "+std::string(__DATE__)+".";

const std::string priorityList[] = {
"book",
"inbook",
"booklet",
"incollection",
"article",
"narticle",
"phdthesis",
"mastersthesis",
"conference",
"proceedings",
"inproceeding",
"inproceedings",
"techreport",
"manual",
"misc",
"unpublished",
"END"
};

const std::string a="@string";
const std::string b="@";
const std::string c="%";
std::string getline(std::istream& in);
bool equal(const std::string& s1, const std::string& s2);
std::string removeBlanks(std::string s);
std::string removeAllBlanks(std::string s);
std::string uppercase(std::string word);
std::string lowercase(std::string word);
int priority(const std::string& s1, const std::string& s2);

struct ltstrNocase {
  bool operator()(const std::string& s1, const std::string& s2) const{
#ifdef NOCASE
    return strcmp(uppercase(s1).c_str(),uppercase(s2).c_str()) < 0;
#else
    return strcmp(s1.c_str(),s2.c_str()) < 0;
#endif
  }
};


int main (int argc, char* argv[]){

  std::cerr <<copyright<<std::endl<<std::endl;
  // Check for help and enough input parameter
  if (argc !=3 || (argc == 2 && (std::string(argv[1]) =="-h" ||
				 std::string(argv[1]) =="--help" ))){
    usage(argv[0]);
    exit(0);
  }

  // Input file name
  std::string inputname = std::string(argv[1]);
  std::ifstream input;
  input.open(inputname.c_str(), std::ios::in);
  if(!input){
    std::cerr<< "Could not open \'"<<inputname<<"\'.\n";
    usage(argv[0]);
    exit(0);
  }
  std::cerr<< "Reading \'"<<inputname<<"\'.\n";
  std::set<std::string> strings;
  //std::set<std::string> forms;
  std::multiset<std::string> stringsRest;
  std::map<std::string,std::pair<std::vector<std::string>,std::string>,ltstrNocase> entries;
  std::multimap<std::string,std::vector<std::string> > entriesRest;
  std::string str;
  str = removeBlanks(getline(input));
  while(!input.eof()){
    if(str.size() > a.size() && equal(str,a)){
      std::set<std::string>::iterator itr = strings.find(str);
      if(itr == strings.end()){
	//std::cerr<< "Found @string (\""<<str<<"\")\n";
	strings.insert(str);
      }
      else {
	//std::cerr<< "Found @string (\""<<str<<"\"), multiple entry\n";
	stringsRest.insert(str);	
      }
      str = removeBlanks(getline(input));
    }
    else if(str.size() > b.size()&& equal(str,b)){
      std::vector<std::string> entry;
      str = removeAllBlanks(str);
      entry.push_back(str);
      std::string mykey = "";
      std::string form = "";
      bool start = false;
      for(unsigned int i=0;i<str.size();i++){
	if(str[i] == ','){
	  break;
	}
	if(start){
	  mykey += str[i];
	}
	if(str[i] =='{' || str[i] =='('){
	  start = true;
	}
	if(!start && str[i] != '@')
	  form += str[i];
      }
      form = lowercase(form);
      //forms.insert(form);
      //std::cerr<< "Found @entry (\""<<str<<"\"), key (\""<<mykey<<"\")\n";
      
      while(!input.eof()){     
	std::string tmp = getline(input);
	str = removeBlanks(tmp);
	
	if((str.size() > a.size() && equal(str,a)) ||
	   (str.size() > b.size()&& equal(str,b))){	  
	  break;
	} 
	else if((!(str.size() >= c.size() && equal(str,c))) && str.size()>0){
	  entry.push_back(tmp);	  
	}
      }

      std::map<std::string,std::pair<std::vector<std::string>,std::string>,ltstrNocase>::iterator itr = entries.find(mykey);
      if(itr == entries.end()){
	entries.insert(std::pair<std::string,std::pair<std::vector<std::string>,std::string> >(mykey,std::pair<std::vector<std::string>,std::string>(entry,form)));
      }
      else{
	//std::cerr<< "Dublicate\n";
	int p = priority(itr->second.second,form);
	
	if(p < 0 || (p == 0 && (mykey < itr->first))){
	  //std::cerr<< "Found dublicate (\""<<itr->second.second<<"\",\""<<form<<"\")\n";
	  
	  entriesRest.insert(std::pair<std::string,std::vector<std::string> >(mykey,entry));
	}
	else {
	  //std::cerr<< "Found dublicate with higher priority (\""<<itr->second.second<<"\",\""<<form<<"\")\n";
	  entriesRest.insert(std::pair<std::string,std::vector<std::string> >(itr->first,itr->second.first));
	  // erase to remove the old key.
	  entries.erase(itr);
	  entries.insert(std::pair<std::string,std::pair<std::vector<std::string>,std::string> >(mykey,std::pair<std::vector<std::string>,std::string>(entry,form)));	  
	}
      }
      
    } else{
      //std::cerr<< "Found comments (\""<<str<<"\")\n";
      str = removeBlanks(getline(input));
    }
  }
  input.close();

  std::cerr<< "Total "<<entriesRest.size()+entries.size()<<" entries found, where "<<entries.size()<<" unique.\n";
  //for(std::set<std::string>::iterator itr = forms.begin();
  //    itr != forms.end(); itr++)
  //  std::cerr<< (*itr)<<"\n";
  
  // Output 
  std::string outputname = std::string(argv[2]);
  std::ofstream output;
  output.open(outputname.c_str(), std::ios::out); 
  for(std::set<std::string>::iterator itr = strings.begin();
      itr != strings.end(); itr++){
    output <<(*itr)<<"\n";
  }
  for(std::map<std::string,std::pair<std::vector<std::string>,std::string>,ltstrNocase>::iterator itr = entries.begin();
      itr != entries.end(); itr++){
    output <<"\n";
    const std::vector<std::string>& entry = itr->second.first;
    for(int i=0;i<entry.size();i++)
      output << entry[i]<<"\n";
  }
  output.close();
  std::cerr<< "Wrote \'"<<outputname<<"\'.\n";

  if(!stringsRest.empty() || !entriesRest.empty()){
    std::string outputnameRest = outputname+".rest";
    std::ofstream outputRest;
    outputRest.open(outputnameRest.c_str(), std::ios::out); 
    for(std::multiset<std::string>::iterator itr = stringsRest.begin();
	itr != stringsRest.end(); itr++){
      outputRest <<(*itr)<<"\n";
    }
    for(std::multimap<std::string,std::vector<std::string> >::iterator itr = entriesRest.begin();
	itr != entriesRest.end(); itr++){
      outputRest <<"\n";
      const std::vector<std::string>& entry = itr->second;
      for(int i=0;i<entry.size();i++)
	outputRest << entry[i]<<"\n";
    }
    outputRest.close();
    std::cerr<< "Wrote \'"<<outputnameRest<<"\'.\n";
  }
  else {
    std::cerr<< "No duplicates.\n";
  }

  return 0;

}

void usage(char* name){
  std::cerr << "Usage: "<<name<<" <inputname> <outputname>"<<std::endl;
}

std::string getline(std::istream& in){
  char a;
  std::string str = "";
  while(in.get(a)){
    if(a == '\n')
      break;
    str += a;
  }
  return str;
}

bool equal(const std::string& s1, const std::string& s2){
  unsigned int count = (s2.size() < s1.size() ? s2.size(): s1.size());
  std::string str1 = lowercase(s1);
  std::string str2 = lowercase(s2);

  for(unsigned int i=0;i<count;i++)
    if(str1[i] != str2[i])
      return false;
  return true;
}

std::string removeBlanks(std::string s){
  for(int i=0;i<s.size();i++){
    if(s[i] != ' ' && s[i] != '\t'){
      for(int j=s.size()-1;j>=i;j--){
	if(s[j] != ' ' && s[j] != '\t'){
	  return s.substr(i,j+1-i);	  
	}
      }
    }
  }
  return "";
}
std::string removeAllBlanks(std::string s){
  std::string tmp = "";
  
  for(int i=0;i<s.size();i++){
    if(s[i] != ' ' && s[i] != '\t' && s[i] != '\n')
      tmp += s[i];
  }
  return tmp;
}

std::string lowercase(std::string word){
#ifdef NOCASE
  std::string ret_str = "";

  for (unsigned int index = 0; index < word.size(); index++)
    ret_str += ::tolower(word[index]);

  return ret_str;
#else
  return word;
#endif
}

std::string uppercase(std::string word){
#ifdef NOCASE
  std::string ret_str = "";

  for (unsigned int index = 0; index < word.size(); index++)
    ret_str += ::toupper(word[index]);

  return ret_str;
#else
  return word;
#endif
}

int priority(const std::string& s1, const std::string& s2){

  int a1=-1;
  int a2=-1;
  int i=0;
  while(priorityList[i] != "END" && (a1 < 0 || a2 < 0)){
    if(lowercase(s1) == lowercase(priorityList[i]))
      a1 = i;
    if(lowercase(s2) == lowercase(priorityList[i]))
      a2 = i;
    i++;
  }
  if( a1 < 0 && a2 < 0)
    return 0;
  else if(a1 < 0)
    return -1;
  else if(a2 < 0)
    return 1;
  else if(a1 < a2)
    return 1;
  else if(a2 < a1)
    return -1;
  else 
    return 0;      
}