package drumconvertor;

import java.io.File;
import java.util.HashMap;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.Track;

/**
 * Midi File
 * @author Honza
 */
public class MidiFile
{
    Sequencer seq;
    Sequence sequence;
    File mFile=null;

    /**************************************************************************/
    /**
     * Constructor
     */
    public MidiFile()
    {
        try
        {
            seq=MidiSystem.getSequencer();
            seq.open();

        }catch(Exception e){
            System.err.println("Cannot create MIDI sequencer");
        }
    }

    /**************************************************************************/
    /**
     * Open
     */
    public void open(String fileName)throws Exception
    {
        mFile=new File(fileName);
        sequence=MidiSystem.getSequence(mFile);
        if( sequence==null )throw new Exception("No MIDI data");
    }

    /**************************************************************************/
    /**
     * Save
     */
    public void save(String fileName)throws Exception
    {
       MidiSystem.write(sequence,1, mFile);
    }

    /**************************************************************************/
    /**
     * Get Midi file Info
     */
    public String getInfo()
    {
        if( mFile==null )return "";
        String info="";

        info="Length: " + sequence.getTickLength() + " ticks\n"+
             "Duration: " + (sequence.getMicrosecondLength()/1000) + " seconds\n" +
             "Tracks:" +sequence.getTracks().length+"\n";
        //
        return info;
    }

    /**************************************************************************/
    /**
     * Get all tracks info
     */
    public String[] getAllTracksInfo()
    {
        Track[] t=sequence.getTracks();
        Track tr;
        String[] info=new String[t.length];

        for( int i=0; i<t.length; i++ )
        {
            tr=t[i];
            info[i]="Events: "+tr.size()+", "+
                    "Ticks: "+tr.ticks();
        }

        //
        return info;
    }

    /**************************************************************************/
    /**
     * Convert track
     */
    public void convertTrack(int track,HashMap<String,String> convertMap)throws Exception
    {
        //if track<=0 => ALL
        if( track>sequence.getTracks().length )throw new Exception("Track #"+track+" does not exist!");
        
        if( track>0 )convertTrackNumber(sequence.getTracks()[track-1], convertMap);
        else
            {
                for( int i=0; i<sequence.getTracks().length; i++)
                {
                    convertTrackNumber(sequence.getTracks()[i], convertMap);
                }
            }
    }

    /**************************************************************************/
    /**
     * Play
     */
    public void play()
    {
        try
        {
            seq.setMicrosecondPosition(0);
            seq.setSequence(sequence);
            seq.start();
        }catch(Exception e){e.printStackTrace();}
    }

    /**************************************************************************/
    /**
     * Stop
     */
    public void stop()
    {
        try
        {
            seq.setSequence(sequence);
            seq.stop();
        }catch(Exception e){e.printStackTrace();}
    }

    /**************************************************************************/
    /**
     * Convert track
     */
    private void convertTrackNumber(Track track,HashMap<String,String> convertMap)throws Exception
    {
        System.out.println("Converting track...");
        //for each event
        MidiEvent e;
        MidiMessage me;
        ShortMessage sm;
        byte mb[];
        int n;
        int added=0;

        MidiEvent[] converted=new MidiEvent[ track.size() ];

        //for all events
        for( int i=0; i<track.size(); i++ )
        {
            e=track.get(i);
            me=e.getMessage();
            mb=me.getMessage();

            //type
            n=getByteValue( mb[0] ); //first byte
            if( !(n>=128 && n<=159 ) )continue; //no note

            System.out.print("Note: "+mb[1]);
            //transpose second byte            
            for( String key: convertMap.keySet() ) //try to find note in table
            {
                if( noteToByte(key)==mb[1] ) //found
                {                                        
                    mb[1]=noteToByte( convertMap.get(key) );
                    sm=new ShortMessage();
                    sm.setMessage(mb[0], mb[1], mb[2] );
                    converted[added++]=new MidiEvent( sm , e.getTick() );

                    System.out.print(" - converted: "+key+" -> "+convertMap.get(key)+" (note: "+mb[1]+")");
                    break;
                }
            }
            //
            System.out.println(""); //end of line
        }

        //remove old note events
        for( int i=track.size()-1; i>=0; i-- )
        {
            e=track.get(i);
            me=e.getMessage();
            mb=me.getMessage();

            //type
            n=getByteValue( mb[0] ); //first byte
            if( !(n>=128 && n<=159 ) )continue; //no note

            track.remove( e );
        }

        //add new transposed note events
        for( int i=0; i<added; i++)
        {
            track.add( converted[i] );
        }

        //
        System.out.println("Converting track done");
    }

    /**************************************************************************/
    /**
     * Get Byte balue
     */
    private int getByteValue(byte b)
    {
        return b+Byte.MAX_VALUE-Byte.MIN_VALUE+1;
    }

    /**************************************************************************/
    /**
     * note to byte
     */
    private byte noteToByte(String note)
    {
        String scale="C_D_EF_G_A_B";
        char a,b,c; //a=note; b=octave; c= # or b
        a=note.charAt(0);
        
        if( note.length()==2 )
        {
            b=note.charAt(1);
            c='0';
        }else{
            b=note.charAt(2);
            c=note.charAt(1);
        }

        //position in scale
        int pos;
        if( a=='H' )pos=scale.indexOf('B'); //czech etc... equivalent for B (f.e. american)
            else pos=scale.indexOf(a);
        
        if( pos<0 || pos>11 )return 0; //invalid input check
        if( b<'0' || b>'9')return 0;

        int out=(pos)+(b-'0')*12; //octave + note
        if( c=='#' )out++; //# or b
            else if( c=='b' || c=='B' )out--;
        
        //return
        return (byte)out;
    }
}