//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Fri Apr  8 10:04:27 PDT 2016
// Last Modified: Fri Apr  8 10:04:30 PDT 2016
// Filename:      ...museinfo/examples/all/arcplot.cpp
// Web Address:   http://sig.sapp.org/examples/museinfo/humdrum/arcplot.cpp
// Syntax:        C++; museinfo
//
// Description:   Generate arcplot.
//
//

#include "humdrum.h"
#include <stdlib.h>

#include <iostream>
#include <sstream>
#include <sstream>
#include <vector>
#include <algorithm>

using namespace std;

#define REST 0
#define RESTINT -1000000
#define MARKNOTES  1


class NoteNode {
   public:
      int b40;                  // base-40 pitch number or 0 if a rest
      int b7;                   // base-7 pitch number or 0 if a rest
      int b12;                  // base-7 pitch number or 0 if a rest
      int line;                 // line number in original score of note
      int spine;                // spine number in original score of note
      RationalNumber duration;  // duration

      void clear(void);
      NoteNode(void)      { clear(); }
      NoteNode(const NoteNode& anode);
      NoteNode& operator=(NoteNode& anode);
     ~NoteNode(void);
      int isRest(void)    { return b40 == REST ? 1 : 0; }
};


NoteNode::NoteNode(const NoteNode& anode) {
   b40        = anode.b40; 
   b12        = anode.b12; 
   b7         = anode.b7; 
   line       = anode.line; 
   spine      = anode.spine; 
   duration   = anode.duration;
}


NoteNode& NoteNode::operator=(NoteNode& anode) {
   if (this == &anode) {
      return *this;
   }
   b40        = anode.b40; 
   b12        = anode.b12; 
   b7         = anode.b7; 
   line       = anode.line; 
   spine      = anode.spine; 
   duration   = anode.duration;
   return *this;
}


NoteNode::~NoteNode(void) {
	clear();
}


void NoteNode::clear(void) { 
   line = spine = b40 = b12 = b7 = -1;
}



///////////////////////////////////////////////////////////////////////////

// function declarations
void      checkOptions         (Options& opts, int argc, char* argv[]);
void      example              (void);
void      usage                (const char* command);
void      processSection       (ostream& out, HumdrumFile& infile, int windex);
void      fillNoteArray        (vector<vector<NoteNode> >& notes, 
                                HumdrumFile& infile);
void      printNotes           (vector<vector<NoteNode> >& notes);
void      compareSequence      (ostream& out, vector<vector<NoteNode> >& notes,
                                int targeti, int targetj);
int       isEqual              (int interval, vector<int>& diff);

// global variables
Options   options;             // database for command-line arguments
int       ngram = 4;           // number of tokens in sequence to examine;


///////////////////////////////////////////////////////////////////////////


int main(int argc, char** argv) {
   checkOptions(options, argc, argv);
   HumdrumStream streamer(options);
   HumdrumFile infile;

   stringstream contents;
   int counter = 0;
   while (streamer.read(infile)) {
		counter++;
      processSection(contents, infile, counter);
   }

   // print header
   
   cout << contents.str();
   
   // print footer
}


///////////////////////////////////////////////////////////////////////////



//////////////////////////////
//
// processSection --
//

void processSection(ostream& out, HumdrumFile& infile, int windex) {
   vector<vector<NoteNode> > notes;
   fillNoteArray(notes, infile);
   // printNotes(notes);
   int i, j;
   for (i=0; i<(int)notes.size(); i++) {
      for (j=0; j<(int)notes[i].size(); i++) {
         if (j < (int)notes[i].size() - ngram) {
            compareSequence(out, notes, i, j);
         } else {
            break;
         }
      }
   }
}



//////////////////////////////
//
// compareSequences --
//

void compareSequence(ostream& out, vector<vector<NoteNode> >& notes,
      int targeti, int targetj) {
   int i, j, n;
   vector<int> target;
   target.resize(ngram);
   for (n=0; n<ngram; n++) {
      if (targetj + n > (int)notes[targeti].size()) {
         return;
      }
      target[n] = notes[targeti][targetj+n].b7;
   }
   vector<int> diff;
   diff.resize(ngram);
   int interval = 0;

   // check the current voice for matches
   for (j = targetj+1; j<(int)notes[targeti].size() - ngram; j++) {
      for (n=0; n<ngram; n++) {
         diff[n] = target[n] - notes[targeti][j].b7;
         if (isEqual(interval, diff)) {
            cout << "FOUND MATCH:" << interval << "\n";
         }
      }
   }

   // check in later voices
   for (i = targeti + 1; i<(int)notes.size(); i++) {
      for (j = 0; j<(int)notes[i].size() - ngram; j++) {
         for (n=0; n<ngram; n++) {
            diff[n] = target[n] - notes[targeti][j].b7;
            if (isEqual(interval, diff)) {
               cout << "FOUND MATCH:" << interval << "\n";
            }
         }
      }
   }

}



//////////////////////////////
//
// isEqual --
//

int isEqual(int interval, vector<int>& diff) {
   interval = 0;
   int nonzero = 0;
   for (int i=0; i<(int)diff.size(); i++) {
      if (diff[i] != 0) {
         if (nonzero == 0) {
            nonzero = diff[i];
         } else {
           if (nonzero != diff[i]) {
              return 0;
           }
         }
      }
   }
   interval = nonzero;
   return 1;
}



//////////////////////////////
//
// printNotes --
//

void printNotes(vector<vector<NoteNode> >& notes) {
   for (int i=0; i<(int)notes.size(); i++) {
      for (int j=0; j<(int)notes[i].size(); j++) {
         cout << notes[i][j].b40 << " ";
      }
      cout << "\n" << endl;
   }
}



//////////////////////////////
//
// fillNoteArray --
//

void fillNoteArray(vector<vector<NoteNode> >& notes, HumdrumFile& infile) {
   vector<int> ktracks;
   int i, j, k;
   infile.getKernTracks(ktracks);
   notes.resize(ktracks.size());
   for (i=0; i<(int)notes.size(); i++) {
      notes[i].reserve(infile.getNumLines());
   }
   NoteNode note;
   string token;
   int b40, b12, b7;
   PerlRegularExpression pre;
   RationalNumber duration = 0;
   for (k=0; k<(int)ktracks.size(); k++) {
      for (i=0; i<infile.getNumLines(); i++) {
         if (!infile[i].isData()) {
				continue;
			}
         for (j=0; j<infile[i].getFieldCount(); j++) {
            if (infile[i].getPrimaryTrack(j) != ktracks[k]) {
               continue;
            }
            if (infile[i].isNullToken(j)) {
               continue;
            }
            token = infile[i][j];
            pre.sar(token, " .*", "");
            if (pre.search(token, "[]_]")) {
               continue;
            }
            if (pre.search(token, "r")) {
               if (note.b40 == REST) {
                  // don't duplicate rest tokens.
                  continue;
               } else {
                  b7 = b12 = b40 = REST;
                  duration = 0;  // fix later 
               }
				} else {
               b40      = Convert::kernToBase40(token.c_str());
               b12      = Convert::base40ToMidiNoteNumber(b40);
               b7       = Convert::base40ToDiatonic(b40);
               duration = Convert::kernToDurationR(token.c_str());
            }
            note.b40 = b40;
            note.b12 = b12;
            note.b7  = b7;
            note.line = i;
            note.spine = j;
            notes[k].push_back(note);
         }
      }
   }
}



//////////////////////////////
//
// checkOptions -- validate and process command-line options.
//

void checkOptions(Options& opts, int argc, char* argv[]) {
   opts.define("n|count=i:4", "Number of tokens to consider in sequence");

   opts.define("author=b");             // author of program
   opts.define("version=b");            // compilation info
   opts.define("example=b");            // example usages
   opts.define("help=b");               // short description
   opts.process(argc, argv);
   
   // handle basic options:
   if (opts.getBoolean("author")) {
      cout << "Written by Craig Stuart Sapp, "
           << "craig@ccrma.stanford.edu, April 2016" << endl;
      exit(0);
   } else if (opts.getBoolean("version")) {
      cout << argv[0] << ", version: April 2016" << endl;
      cout << "compiled: " << __DATE__ << endl;
      cout << MUSEINFO_VERSION << endl;
      exit(0);
   } else if (opts.getBoolean("help")) {
      usage(opts.getCommand().c_str());
      exit(0);
   } else if (opts.getBoolean("example")) {
      example();
      exit(0);
   }

   ngram = opts.getInteger("count");
}



//////////////////////////////
//
// example -- example usage of the quality program
//

void example(void) {
   cout <<
   "                                                                         \n"
   << endl;
}



//////////////////////////////
//
// usage -- gives the usage statement for the meter program
//

void usage(const char* command) {
   cout <<
   "                                                                         \n"
   << endl;
}


// md5sum: 1199ad6ab0213242f31d2c8edb18a7d7 arcplot.cpp [20170605]