//
// AeN64DriverNotify.c++
//
// This file contains the client notify handlers that
// are called by the assetbase in response to actions
// made on assets such as create, update, delete, etc.
//
// Since bank assets and fx assets are treated so
// differently by the n64, i have separated out their
// handling into different routines for clarity.
//

#include <assert.h>

#include "AeN64Driver.h"
#include "AeConfig.h"
#include "AeAsset.h"
#include "AeAssetBase.h"
#include "GList.h"


void
AeN64Driver::CreateAsset (AeAsset * asset, Boolean suspended)
{
    assert (asset);

    if (asset->IsBankComponent ())
	createBankAsset (asset, suspended);

    else if (asset->IsFxComponent ())
	createFxAsset (asset, suspended);
}


void
AeN64Driver::createBankAsset (AeAsset * asset, Boolean suspended)
{
    allocBankMem (asset);

    if (asset->GetType () == kBankType)
	fBank = (AeBankAsset *)asset;

    updateBankAsset (asset, suspended);
}


void
AeN64Driver::createFxAsset (AeAsset * asset, Boolean suspended)
{
    updateFxAsset (asset, suspended);
}


void
AeN64Driver::UpdateAsset (AeAsset * asset, Boolean suspended)
{
    assert (asset);

    if (asset->IsBankComponent ())
	updateBankAsset (asset, suspended);

    // pass non-bank updates through (eg. fx updates)
    else if (asset->IsFxComponent ())
	updateFxAsset (asset, suspended);
}

// if a bank asset changes, make sure the bank
// is still loadable before proceeding with the update.
// if we're suspended, do nothing since resume will handle it.
void
AeN64Driver::updateBankAsset (AeAsset * asset, Boolean suspended)
{
    if (!suspended && checkBank ())
	updateAsset (asset);
}


void
AeN64Driver::updateFxAsset (AeAsset * asset, Boolean suspended)
{
    checkFx ();			// make sure the effect is still okay
    updateAsset (asset);	// update the asset
}


void
AeN64Driver::DeleteAsset (AeAsset * asset, Boolean suspended)
{
    assert (asset);

    if (asset->IsBankComponent ())
	deleteBankAsset (asset, suspended);

    else if (asset->IsFxComponent ())
	deleteFxAsset (asset, suspended);
}


void
AeN64Driver::deleteBankAsset (AeAsset * asset, Boolean suspended)
{
    // if the deleted asset is the current bank, then tell the UI to offline it
    if (asset == fBank)
    {
	fBank->SetOnline (False);
	fAssetBase->NotifyOnline (fBank);
	fBank = NULL;
    }

    // if we're not suspended the check the bank's loadability	
    if (!suspended)
	checkBank ();

    deallocBankMem (asset);
}


void
AeN64Driver::deleteFxAsset (AeAsset * asset, Boolean suspended)
{
    // if the asset being deleted is the current fx, the invalidate the fx
    if (asset == fConfig->GetFxAsset ())
	fConfig->SetFxAsset (NULL);

    // if we're not suspended the check the effect's loadability	
    if (!suspended)
	checkFx ();
}


void
AeN64Driver::OnlineAsset (AeAsset * asset, Boolean suspended)
{
    if (asset->IsBankComponent ())
	onlineBankAsset (asset, suspended);

    else if (asset->IsFxComponent ())
	onlineFxAsset (asset, suspended);
}


void
AeN64Driver::onlineBankAsset (AeAsset * asset, Boolean suspended)
{
    // we currently don't allow the user to put banks on and offline
    if (asset == fBank && isBankLoadable ())
	asset->SetOnline (True);
}


void
AeN64Driver::onlineFxAsset (AeAsset * asset, Boolean suspended)
{
    if (asset->GetType () == kFxType)
    {
	AeFxAsset * fxAsset = fConfig->GetFxAsset ();
	AeErr err;

	// if asset is not loadable then take asset offline
	if (!isFxLoadable ((AeFxAsset *)asset))
	{
	    asset->SetOnline (False);

	    if (fxAsset != asset)
		return;	    
	}
	
	// if asset is to be put online, then take any currently
	// online asset offline
	if (asset->IsOnline ())
	{
	    if (fxAsset)
	    {
		fxAsset->SetOnline (False);
		fAssetBase->NotifyOnline (fxAsset);
	    }
	}

	// if asset is to be put offline, then indicate this
	// by setting the currently configured fx to NULL
	else
	{
	    assert (asset == fxAsset);
	    asset = NULL;
	}

	fConfig->SetFxAsset ((AeFxAsset *)asset);
	
	fNeedsConfigure = True;
	if (!suspended && (err = ReconfigureAudio ()))
	{
	    if (asset)
		asset->SetOnline (False);
	}
    }    
}


void
AeN64Driver::UpdateResume (void)
{
    if (fNeedsConfigure)
    {
	ReconfigureAudio ();
    }
    else
    {
	// if the fx don't cause the bank to be reloaded
	// then reload the bank
	if (!checkFx ())
	{
	    if (isBankLoadable ())
		loadBank ();

	    else if (fBankOnlineHW)
		unloadBank ();
	}
    }
}



//
// call this routine to correctly place the bank
// online or offline depending on the loadability
// of the current bank.
//
Boolean
AeN64Driver::checkBank (void)
{
    if (isBankLoadable ())
    {
	if (!fBankOnlineHW)
	    loadBank ();
    }
    else
    {
	if (fBankOnlineHW)
	    unloadBank ();
    }

    return fBankOnlineHW;
}


Boolean
AeN64Driver::isBankOnline (void)
{
    return fBank && fBank->IsOnline ();
}


//
// Returns true if the bank is complete enough
// to safely download to the n64.  Otherwise returns false.
//
// The bank asset must exist
// The bank asset must have at least one instrument
//	(else initFromBank will loop forever)
// The bank's instruments must have at least one sound
//	(this is just for consistency, i don't think it would crash the n64)
// The bank's sounds must all have keymaps
//	(else midiNoteOn, lookupSoundQuick will dereference a missing keymap)
// The bank's sounds must all have wavetables
//	(else midiNoteOn will dereference a missing wavetable)
// The bank's sounds must all have envelopes
//	(else midiNoteOn will dereference a missing envelope)
//
Boolean
AeN64Driver::isBankLoadable (void)
{
    GList<AeAsset *> *	childList;
    AeAsset *		child;
    int			i;
    AeInstAsset *	percussion;

    if (!fBank)
	return False;

    childList = fBank->GetChildList ();
    assert (childList);

    if (childList->GetNum () == 0)
	return False;

    childList->Start (i);
    while (childList->Next (i, child))
	if (!isInstLoadable ((AeInstAsset *)child))
	    return False;

    if (percussion = fBank->GetPercussion ())
	if (!isInstLoadable (percussion))
	    return False;

    return True;
}


Boolean
AeN64Driver::isInstLoadable (AeInstAsset * asset)
{
    GList<AeAsset *> *	childList;
    AeAsset *		child;
    int			i;

    assert (asset);

    childList = asset->GetChildList ();
    assert (childList);

    if (childList->GetNum () == 0)
	return False;

    childList->Start (i);
    while (childList->Next (i, child))
	if (!isSoundLoadable ((AeSoundAsset *)child))
	    return False;

    return True;
}


Boolean
AeN64Driver::isSoundLoadable (AeSoundAsset * asset)
{
    assert (asset);

    if (asset->GetKeymap () == NULL)
	return False;

    if (asset->GetEnvelope () == NULL)
	return False;

    if (asset->GetWave () == NULL)
	return False;

    return True;
}


//
// Returns True if the effect is complete enough
// to be downloaded to the n64 safely (ie so it
// won't cause the n64 to crash).
//
// The only criterion is that the effect contains
// at least one section.
//
Boolean
AeN64Driver::isFxLoadable (AeFxAsset * asset)
{
    GList<AeAsset *> *	childList;

    if (asset)
    {
	childList = asset->GetChildList ();
	assert (childList);

	if (childList->GetNum () > 0)
	    return True;
    }

    return False;
}


//
// call this routine to check if the fx should
// no longer be online and take it offline if
// it is not loadable.  since fx are manually put
// online, there is no need to automatically load it.
// this is important if the user removes all the
// children of an effect.
//
Boolean
AeN64Driver::checkFx (void)
{
    AeFxAsset * fxAsset;

    if (fxAsset = fConfig->GetFxAsset ())
    {
	if (!isFxLoadable (fxAsset) && isFxOnline (fxAsset))
	{
	    fxAsset->SetOnline (False);
	    fAssetBase->NotifyOnline ((AeAsset *)fxAsset);
	    return True;
	}	    
    }

    return False;
}


Boolean
AeN64Driver::isFxOnline (AeAsset * asset)
{
    if (!asset)
	return False;

    if (asset->GetType () == kFxSxnType)
	return isFxSxnOnline ((AeFxSxnAsset *)asset);

    return asset->IsOnline ();
}


Boolean
AeN64Driver::isFxSxnOnline (AeFxSxnAsset * asset)
{
    GList<AeAsset *> *	parentList;
    AeAsset *		parent;
    Boolean		loaded = False;

    assert (asset->GetType () == kFxSxnType);

    parentList = asset->GetParentList ();

    if (parentList->GetNum () > 0)
    {
        // only 1 parent allowed per fx section
	assert (parentList->GetNum () == 1);	

	parent = (*parentList)[0];
	loaded =  parent->IsOnline ();
    }

    return loaded;
}