/*
 * Copyright 2006, Haiku.
 *
 * Copyright (c) 2002-2004 Matthijs Hollemans
 * Copyright (c) 2003 Jerome Leveque
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              
 *              Matthijs Hollemans
 *              Jérôme Leveque
 */

#include "debug.h"
#include <MidiStore.h>
#include <MidiSynthFile.h>
#include "SoftSynth.h"

using namespace BPrivate;


BMidiSynthFile::BMidiSynthFile()
{
        fStore = new BMidiStore();
}


BMidiSynthFile::~BMidiSynthFile()
{
        Stop();
        delete fStore;
}


status_t 
BMidiSynthFile::LoadFile(const entry_ref* midi_entry_ref)
{
        if (midi_entry_ref == NULL)
                return B_BAD_VALUE;

        EnableInput(true, false);
        fStore->fFinished = true;

        status_t err = fStore->Import(midi_entry_ref);

        if (err == B_OK) {
                for (int t = 0; t < 128; ++t) {
                        if (fStore->fInstruments[t]) {
                                be_synth->fSynth->LoadInstrument(t);
                        }
                }
        }
        
        return err;
}


void 
BMidiSynthFile::UnloadFile(void)
{
        delete fStore;
        fStore = new BMidiStore();
}


status_t 
BMidiSynthFile::Start(void)
{
        fStore->Connect(this);
        fStore->SetCurrentEvent(0);
        return fStore->Start();
}


void 
BMidiSynthFile::Stop(void)
{
        fStore->Stop();
        fStore->Disconnect(this);
}


void 
BMidiSynthFile::Fade(void)
{
        Stop();  // really quick fade :P
}


void 
BMidiSynthFile::Pause(void)
{
        fStore->fPaused = true;
}


void 
BMidiSynthFile::Resume(void)
{
        fStore->fPaused = false;
}


int32 
BMidiSynthFile::Duration(void) const
{
        return fStore->DeltaOfEvent(fStore->CountEvents());
}


int32 
BMidiSynthFile::Position(int32 ticks) const
{
        return fStore->EventAtDelta(ticks);
}


int32 
BMidiSynthFile::Seek()
{
        return fStore->CurrentEvent();
}


status_t 
BMidiSynthFile::GetPatches(
        int16* pArray768, int16* pReturnedCount) const
{
        int16 count = 0;
        
        for (int t = 0; t < 128; ++t) {
                if (fStore->fInstruments[t]) {
                        pArray768[count++] = t;
                }
        }

        *pReturnedCount = count;
        return B_OK;
}


void 
BMidiSynthFile::SetFileHook(synth_file_hook pSongHook, int32 arg)
{
        fStore->fHookFunc = pSongHook;
        fStore->fHookArg = arg;
}


bool 
BMidiSynthFile::IsFinished() const
{
        return fStore->fFinished;
}


void 
BMidiSynthFile::ScaleTempoBy(double tempoFactor)
{
        fStore->SetTempo((int32) (Tempo() * tempoFactor));
}


void 
BMidiSynthFile::SetTempo(int32 newTempoBPM)
{
        fStore->SetTempo(newTempoBPM);
}


int32 
BMidiSynthFile::Tempo(void) const
{
        return fStore->Tempo();
}


void 
BMidiSynthFile::EnableLooping(bool loop)
{
        fStore->fLooping = loop;
}


void 
BMidiSynthFile::MuteTrack(int16 track, bool do_mute)
{
        fprintf(stderr, "[midi] MuteTrack is broken; don't use it\n");
}


void 
BMidiSynthFile::GetMuteMap(char* pTracks) const
{
        fprintf(stderr, "[midi] GetMuteMap is broken; don't use it\n");
}


void 
BMidiSynthFile::SoloTrack(int16 track, bool do_solo)
{
        fprintf(stderr, "[midi] SoloTrack is broken; don't use it\n");
}


void 
BMidiSynthFile::GetSoloMap(char* pTracks) const
{
        fprintf(stderr, "[midi] GetSoloMap is broken; don't use it\n");
}


void BMidiSynthFile::_ReservedMidiSynthFile1() { }
void BMidiSynthFile::_ReservedMidiSynthFile2() { }
void BMidiSynthFile::_ReservedMidiSynthFile3() { }