package eu.bandm.music.haken ; 

import java.util.List;
import java.util.ArrayList;
import java.util.Map;

import java.io.File;

import eu.bandm.tools.annotations.Opt ; 

import eu.bandm.tools.util.Rational ; 

import eu.bandm.tools.message.SimpleMessage;
import eu.bandm.tools.message.MessageReceiver;
import eu.bandm.tools.message.MessageCounter;
import eu.bandm.tools.message.MessageFormatter;
import eu.bandm.tools.message.MessagePrinter;
import eu.bandm.tools.message.MessageTee;
import eu.bandm.tools.message.XMLDocumentIdentifier;

import eu.bandm.tscore.model.TimeScape ; 
import eu.bandm.tscore.model.Part ; 
import eu.bandm.tscore.model.Tp ; 
import eu.bandm.tscore.model.Vox ; 
import eu.bandm.tscore.model.Event ; 

import eu.bandm.tscore.base.Util ; 

import eu.bandm.music.entities.RationalDuration.DottedBaseDuration ; 
import eu.bandm.music.entities.QualifiedRational ; 
import eu.bandm.music.entities.MetricConsumer ; 
import eu.bandm.music.entities.MTree ; 
import eu.bandm.music.entities.StemEnd ; 


/** A first version of a haken score for realization by a solo vocalist.
 *  This is the production version for one single vocal output, singing just
 *  vowels and semi-vowels on one fixed pitch.
 *  With one K-voices per parameter "lightness" and "soundness". <br/>
 *  <b>Usage:</b> create an Instance (with an already raw-parsed TimeScape)
 *  and call "update(... score.findVoice(..)..). <br/>
 *  The {@link #main(String[])} method takes filenames and voice names from the command 
 *  line parameters.
 */
public class Score_hkn_vox_v00 extends Score_hkn {

  // ---------------------------------------------------------------------
  // lilypond conversions
  // ---------------------------------------------------------------------

  /** Evident*/
  protected static final Rational rat_3_4 = Rational.valueOf(3,4);
  /** Evident*/
  protected static final QualifiedRational sound_3_4 
    = new QualifiedRational(rat_3_4,  true);
  /** Evident*/
  protected static final Rational rat_1_4 = Rational.valueOf(1,4);
  /** Evident*/
  protected static final QualifiedRational sound_1_4 
    = new QualifiedRational(rat_1_4, true);

  /** Auxiliary module for generating a LilyPond source text as output.*/
  protected final LilypondGenerator lilypondGenerator ; 

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

  /** Only constructor.
   *  @param name of the score, also used to derive output file names
   *  @param ts the raw parsed tscore input data.
   *  @param msg the drain of all messages.
   *  @param parameters control parsing, if left out, derfaults to "new {@link Parameters}".
   */
  public Score_hkn_vox_v00 (final String name, 
			    final Part ts, 
			    final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
                            final @Opt Parameters parameters){
    super(name, ts, msg, parameters);
    lilypondGenerator = new LilypondGenerator(msg);
  }

  /** FIXME DOC*/
  public static Map<String,Score_hkn_vox_v00> fromTimeScape
    (final TimeScape ts,
     final String topName, 
     final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg,
     final @Opt Parameters parameters){
    return Util.partsToScores(ts, topName, "%s_%s", msg, parameters, Score_hkn_vox_v00::new);
  }

  /** The list of RelWert used for the "height" of the sung sound.*/
  List<RelWert> seq_height ; 
  /** The list of RelWert used for the "soundness" of the sung sound.*/
  List<RelWert> seq_vowelness ; 
  
  /** Constant used for the pitch height for all generated V-Events.*/
  public static final String lilypond_constant_pitch = "e''" ; // "h'" ; 
  
  /** List of the length of the pauses from p0=quarter note  to p4=brevis.*/
  final public QualifiedRational[] pauseGrades 
    = {  QualifiedRational.pause(1,4),
	 QualifiedRational.pause(1,2),
	 QualifiedRational.pause(3,4),
	 QualifiedRational.pause(1,1),
	 QualifiedRational.pause(2,1)
  };
  
  /** Highest valid index into {@link #pauseGrades}.*/
  final public int maxPause = pauseGrades.length-1 ; 


  /** Get the duration of the pause to be insert <em>before</em> the event on the
   *  i-th K-time point.
   *  @return null if not pause is specified in the selected voice.
   */
  protected @Opt QualifiedRational getPauseByIndex(final List<Tp> tps,
						   final @Opt Vox vpause,
						   final int i
						   /*GLO event2pause */){
    final int g = getPauseIndexByIndex (tps, vpause, i, maxPause );
    return (g>noPauseSelected) ? pauseGrades[g] : null ; 
  }

  /** Index into the list of durations for the MetricConsumer write out method.
   *  Must be a class field, not a method variable, for mere technical (Java) reasons.
   *  ("external fields referred to from a inner class must be final", etc.)
   */
  int accu_index_writeout ; 

  /** The character representation of the sounds to sing, indexed first by 
   *  vowel-ness (U to O), then by brightness (U to O).
   */
  public static final String[][] lyricSquare 
    = { 
    {  "\u03C7",     "\u0283",  "\u00E7" },
    { "m", "n", "l" },
    { "u", "a", "i" }
  }; 
      
  /**
   * Generate the lilyPond commands for the sequence of K-Evenst.
   * @param max number of K-Events to process
   * @param tps all time points after expansion
   * @param vpause voice selected for the additional articulation pauses
   * @param checkLastForPause whether the last pause ????? FIXME
   */
  protected void writeout(final int max, 
                          final List<Tp> tps, 
                          final @Opt Vox vpause,
                          final boolean checkLastForPause
                          /*GLO IN accu_index, etc.*/ ){
    final @Opt QualifiedRational lastPause 
      = checkLastForPause ? getPauseByIndex(tps, vpause, max) : null ; 
    
    // Step through all time points and mix K-Events (with a fixed duration) and
    // pauses into one list of durations.
    // The list internal in the LilypondGenerator grows IN PARALLEL and 
    // maps the SUM of standard V-Event duration and articulation pauses to the K-events:
    final List<QualifiedRational> durations = new ArrayList<>();
    for (int i = 0;  i<max; i++){
      final @Opt QualifiedRational pause = getPauseByIndex(tps, vpause, i);
      if (pause!=null){
	durations.add(pause);
	lilypondGenerator.addPause(pause.get0(), vpause, tps.get(i)); 
        // = Add to PREVIOUS event. It has been checked that this exists.
      }
      // Add the standard duration 1/4 to the local list of durations and 
      // start a new K-event in the lilypondGenerator:
      durations.add(sound_1_4);
      lilypondGenerator.startGraphEvent(rat_1_4);
    }// for i = all tp indexes

    // FIXME ????
    if (lastPause!=null){
      durations.add(lastPause);
      lilypondGenerator.addPause(lastPause.get0(), vpause, tps.get(max)); // add to PREVIOUS event
    }

    final MetricConsumer mc 
      = MetricConsumer.byDurations(lilypondGenerator.metricSplitter, durations);
    accu_index_writeout = 0 ;

    while (mc.hasNext()){
      mc.getNext();
      if (mc.isIncomplete()){
	mc.discardSyntheticTail();
        // getRestDuration() is negative, generate a shorter measure:
	final Rational restSum = Rational.ONE.add(mc.getRestDuration());
	lilypondGenerator.putF(" \\time "+restSum) ; 
      }
      // Write out one measure. Step through the qualified durations. These are
      // pauses only for the additional artikulation pauses. Otherwise they
      // correspond to a K-Event, which is stepped through by {@link #accu_index_writeout}:
      final MetricConsumer.WriteOut writeOut 
	= mc.new WriteOut(){
	    RelWert rel_h, rel_o ; 
	    boolean needsInit = true ; 
	    public void writeOut (final int index, 
                                  final MTree node,
                                  final DottedBaseDuration dbd,
				  final Rational proportion, 
                                  final StemEnd beams, 
				  final boolean sound, 
                                  final boolean isFirst, 
                                  final boolean isLast){
	      String lil_event = "";
	      assert dbd !=null ; 
	      if (!sound){
		lil_event = "r"+lilypondGenerator.lilypond_duration_encoding(dbd);
	      }
	      else {
		@Opt String lyrics = null ; 
		if (needsInit || isFirst){
		  rel_o = seq_vowelness.get(accu_index_writeout);
		  rel_h = seq_height.get(accu_index_writeout);
		  lyrics = lyricSquare[rel_o.getArrayIndex()][rel_h.getArrayIndex()];
		  needsInit=false ; 
		}
		lil_event 
		  = lilypond_constant_pitch+lilypondGenerator.lilypond_duration_encoding(dbd);
		if (!isLast)
		  lil_event+=lilypondGenerator.lilypond_tie_symbol ; 
		if (isFirst){
		  lil_event+="_\\markup{"+lyrics+"} ";
		  final Tp now = tps.get(accu_index_writeout);
		  if (tp2barnum.containsKey(now))
		    lil_event+="^\\markup{\\small{("+tp2barnum.get(now)+")}}";
		}
		if (isLast)
		  accu_index_writeout++;
	      }//sound
	      lilypondGenerator.putF(lil_event);
	    }
	    @Override public void open_proportion (Rational proportion){
	      throw new AssertionError("shall not happen.");
	    }
	    @Override public void close_proportion (Rational proportion){
	      throw new AssertionError("shall not happen.");
	    }
	  }; //class extends WriteOut
      writeOut.process();
      lilypondGenerator.putF("   |");
    }//mc.hasNext
  }//writeout



  /** Convert the tscore data into a lilypond output.
   *  The input data is read from some global fields ({@link #event2relwert}, etc.)
   *  and from the voices given as explicit arguments.
   *  The result is stored internally in {@link #lilypondGenerator} and can later
   *  be got from there, eg. by {@link LilypondGenerator#writeToFile(String)}.
   *  @param inputFileName only for a comment in the generated lilypond source
   *  @param outputFileStem only for a comment in the generated lilypond source
   *  @param args[2] used for the entry catgory "subtitle" in the header of the
   *     generated lilypond source. "-" stands for "none", 
   *     (The category "title" will be filled by the name of the outputfile,
   *      "subsubtitle" will be a source file indication.)
   *  @param v_pause  voice selected for pause control
   *  @param v_pause  voice selected for pause control
   *  @param v_soundness  voice selected for soundness
   *  @param v_height  voice selected for sound height
   */
  public void update(final String inputFileName,
		     final String scoreAndPartName, 
		     final @Opt String subtitle, 
		     final @Opt Vox v_pause,
		     final Vox v_soundness,
		     final Vox v_height
		     /*GLO OUT lilypondGenerator*/){
    super.update();

    final Expansion exp = new Expansion (v_soundness, v_height);
    exp.expand();

    // needed by WriteOut.writeOut:
    seq_height = exp.expanded.get(v_height);
    seq_vowelness = exp.expanded.get(v_soundness);
    final int len = seq_height.size();
    assert len == seq_vowelness.size() : "height and vowelness lists differ in length" ;
      
      lilypondGenerator.open(inputFileName, scoreAndPartName, subtitle);
      lilypondGenerator.open_score();
      lilypondGenerator.open_staffGroup();
      lilypondGenerator.open_staff("Vox", "Vox");

      // =========================
      writeout(len, exp.tps, v_pause, false);
      // =========================

      lilypondGenerator.putF("  \\bar\"|.\" ") ; 

      lilypondGenerator.close_staff();
      lilypondGenerator.putF(" ");


      // ======================================
      lilypondGenerator.writeGraphics("V-heit", v_soundness, seq_vowelness, exp.tps,
                                      event2relwert, event2haken, event2doppelHaken);
      lilypondGenerator.writeGraphics("Höhe", v_height, seq_height, exp.tps,
                                      event2relwert, event2haken, event2doppelHaken);
      // ======================================

      lilypondGenerator.close_staffGroup();
      lilypondGenerator.close_score();
  }//update 
    

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


  /** Main method, translates input file in HKN-vox format to lilypond output file.
   *  @param args[0] input file name
   *  @param args[1] basic score name  (also determines the output files)
   *  @param args[2] used for the entry catgory "subtitle" in the header of the
   *     generated lilypond source. "-" stands for "none", 
   *     (The category "title" will be filled by the name of the outputfile,
   *      "subsubtitle" will be a source file indication.)
   *  @param args[3] pause voice. "-" stands for "none".
   *  @param args[4..5] Names of the K-Voices to be used for "soundness" and "height" 
   */
  public static void main (String[] args) {

    final MessageCounter mcnt = new MessageCounter();
    final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg 
      = new MessageTee<>(new MessageFormatter<>(new MessagePrinter<>()),
                         mcnt);
    if (args.length<6)
      msg.receive(SimpleMessage.error("not enough command line parameters."));
    mcnt.terminateApplicationOnErrors();

    String message = null ; 
    final String inputfilename =  (args[0]);
    msg.receive(SimpleMessage.logStart("parsing input file %s to raw data", inputfilename));
    final File inputfile = new File(inputfilename) ; 
    final TimeScape ts = Util.parseTimeScape(inputfile, modifiers, msg);
    msg.receive(SimpleMessage.logEnd("parsing input file"));

    mcnt.terminateApplicationOnErrors();
    
    // ====================================================================
    // convert raw model into Score_haken semantic interpretation
    // ====================================================================
    
    msg.receive(SimpleMessage.logStart(message="semantic interpretation"));

    final String scoreNameStem = args[1]; 
    final Map<String,Score_hkn_vox_v00> scores 
      = fromTimeScape(ts,scoreNameStem,msg,null);

    @Opt String subtitle =  args[2]; 
    if (noVoiceSelected.equals(subtitle))
      subtitle = null ; 

    for (final Score_hkn_vox_v00 score : scores.values()){

      final @Opt Vox v_ps = score.findVoice (args[3], true/*=errorNotWarning on spelling error.*/);

      // from here different from "vla":
      final @Opt Vox v_sound = score.findVoice (args[4], true); 
      final @Opt Vox v_height = score.findVoice (args[5], true);
      if (v_sound==null || v_height==null)
        msg.receive(SimpleMessage.error("both voices (for soundness and height) must be given."));
      mcnt.terminateApplicationOnErrors();
      
      // ==========================================
      score.update(inputfilename, score.name, subtitle, v_ps, v_sound, v_height);
      // ==========================================
      
      msg.receive(SimpleMessage.logEnd(message));
    
      // ====================================================================
      // write lilypond format objects to output file
      // ====================================================================
      
      final String outputfilename = score.name+".ly";
      score.lilypondGenerator.writeToFile(outputfilename);
      msg.receive(SimpleMessage.log("result written to %s", outputfilename));
    }// for scores
  }//main



}