//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (c) 1998-1999 Microsoft Corporation
//
//  File:       ptrntrk.h
//
//--------------------------------------------------------------------------

// PtrnTrk.h : Declaration of the Pattern Track info and state structs

#ifndef __PATTERNTRACK_H_
#define __PATTERNTRACK_H_

#include "dmsect.h"
#include "dmstyle.h"

const MUSIC_TIME MAX_END = 2147483647; // max end time for a track

#define DMUS_PATTERN_AUDITION   1
#define DMUS_PATTERN_MOTIF              2
#define DMUS_PATTERN_STYLE              3

#include <time.h>       // to seed random number generator

const long MULTIPLIER = 48271;
const long MODULUS = 2147483647;

class CRandomNumbers
{
public:
        CRandomNumbers(long nSeed = 0)
        {
                nCurrent = (long)(nSeed ? nSeed : time(NULL));
        }

        void Seed(long nSeed)
        {
                nCurrent = nSeed;
        }

        long Next(long nCeiling = 0)
        {
                LONGLONG llProduct = MULTIPLIER * (LONGLONG) nCurrent;
                nCurrent = (long) (llProduct % MODULUS);
                return nCeiling ? nCurrent % nCeiling : nCurrent;
        }

private:
        long nCurrent;
};

struct PatternTrackState;

struct StylePair
{
        StylePair() : m_mtTime(0), m_pStyle(NULL) {}
        ~StylePair() { if (m_pStyle) m_pStyle->Release(); }

        MUSIC_TIME      m_mtTime;
        IDMStyle*       m_pStyle;
};

struct StatePair
{
        StatePair() : m_pSegState(NULL), m_pStateData(NULL) {}
        StatePair(const StatePair& rPair)
        {
                m_pSegState = rPair.m_pSegState;
                m_pStateData = rPair.m_pStateData;
        }
        StatePair(IDirectMusicSegmentState* pSegState, PatternTrackState* pStateData)
        {
                m_pSegState = pSegState;
                m_pStateData = pStateData;
        }
        StatePair& operator= (const StatePair& rPair)
        {
                if (this != &rPair)
                {
                        m_pSegState = rPair.m_pSegState;
                        m_pStateData = rPair.m_pStateData;
                }
                return *this;
        }
        ~StatePair()
        {
        }
        IDirectMusicSegmentState*       m_pSegState;
        PatternTrackState*                      m_pStateData;
};

struct PatternTrackInfo
{
        PatternTrackInfo();
        PatternTrackInfo(const PatternTrackInfo* pInfo, MUSIC_TIME mtStart, MUSIC_TIME mtEnd); 
        virtual ~PatternTrackInfo();
        virtual HRESULT STDMETHODCALLTYPE Init(
                                /*[in]*/  IDirectMusicSegment*          pSegment
                        ) = 0;

        virtual HRESULT STDMETHODCALLTYPE InitPlay(
                                /*[in]*/  IDirectMusicTrack*            pParentrack,
                                /*[in]*/  IDirectMusicSegmentState*     pSegmentState,
                                /*[in]*/  IDirectMusicPerformance*      pPerformance,
                                /*[out]*/ void**                                        ppStateData,
                                /*[in]*/  DWORD                                         dwTrackID,
                /*[in]*/  DWORD                     dwFlags
                        ) = 0;

        HRESULT STDMETHODCALLTYPE EndPlay(
                                /*[in]*/  PatternTrackState*            pStateData
                        );

        HRESULT STDMETHODCALLTYPE AddNotificationType(
                                /* [in] */  REFGUID     pGuidNotify
                        );

        HRESULT STDMETHODCALLTYPE RemoveNotificationType(
                                /* [in] */  REFGUID pGuidNotify
                        );

        PatternTrackState* FindState(IDirectMusicSegmentState* pSegState);

        HRESULT MergePChannels();

        HRESULT InitTrackVariations(CDirectMusicPattern* pPattern);

        TList<StatePair>                        m_StateList;    // The track's state information
        TList<StylePair>                        m_pISList;      // The track's Style interfaces
        DWORD                                           m_dwPChannels; // # of PChannels the track knows about
        DWORD*                                          m_pdwPChannels; // dynamic array of PChannels
        BOOL                                            m_fNotifyMeasureBeat;
        BOOL                                            m_fActive;
//      BOOL                                            m_fTrackPlay;
    BOOL        m_fStateSetBySetParam;  // If TRUE, active flag was set by GUID. Don't override. 
//    BOOL        m_fStatePlaySetBySetParam;  // If TRUE, trackplay flag was set by GUID. Don't override. 
        BOOL            m_fChangeStateMappings; // If TRUE, state data needs to change m_pMappings
        long            m_lRandomNumberSeed;    // If non-zero, use as a seed for variation selection
        DWORD           m_dwPatternTag;                 // replaces need for dynamic casting
        DWORD           m_dwValidate; // used to validate state data
        BYTE*           m_pVariations;          // Track's array of variations (1 per part)
        DWORD*          m_pdwRemoveVariations;  // Track's array of variations already played (1 per part)

};


#define PLAYPARTSF_CLOCKTIME    0x1
#define PLAYPARTSF_FIRST_CALL   0x2
#define PLAYPARTSF_START                0x4
#define PLAYPARTSF_RELOOP               0x8
#define PLAYPARTSF_FLUSH                0x10

struct PatternTrackState
{
        PatternTrackState();
        virtual ~PatternTrackState();
        // methods
        virtual HRESULT Play(
                                /*[in]*/  MUSIC_TIME                            mtStart, 
                                /*[in]*/  MUSIC_TIME                            mtEnd, 
                                /*[in]*/  MUSIC_TIME                            mtOffset,
                                                  REFERENCE_TIME rtOffset,
                                                  IDirectMusicPerformance* pPerformance,
                                                  DWORD                                         dwFlags,
                                                  BOOL fClockTime

                        ) = 0;

        void GetNextChord(MUSIC_TIME mtNow, MUSIC_TIME mtOffset, IDirectMusicPerformance* pPerformance, BOOL fStart = FALSE, BOOL fSkipVariations = FALSE);

        HRESULT ResetMappings()
        {
                HRESULT hr = S_OK;
                if (m_pMappings) delete [] m_pMappings;
                m_pMappings = new MuteMapping[m_pPatternTrack->m_dwPChannels];
                if (!m_pMappings)
                {
                        hr = E_OUTOFMEMORY;
                }
                else
                {
                        for (DWORD dw = 0; dw < m_pPatternTrack->m_dwPChannels; dw++)
                        {
                                m_pMappings[dw].m_mtTime = 0;
                                m_pMappings[dw].m_dwPChannelMap = m_pPatternTrack->m_pdwPChannels[dw];
                                m_pMappings[dw].m_fMute = FALSE;
                        }
                }
                m_pPatternTrack->m_fChangeStateMappings = FALSE;
                return hr;
        }

        void GetNextMute(DWORD dwPart, MUSIC_TIME mtStart, MUSIC_TIME mtNow, MUSIC_TIME mtOffset, IDirectMusicPerformance* pPerformance, BOOL fClockTime)
        {
                HRESULT hr = S_OK;
                if (m_pPatternTrack->m_fChangeStateMappings)
                {
                        hr = ResetMappings();
                }
                if (SUCCEEDED(hr))
                {
                        for (DWORD dw = 0; dw < m_pPatternTrack->m_dwPChannels; dw++)
                        {
                                if ( (m_pPatternTrack->m_pdwPChannels[dw] == dwPart) &&
                                         (0 <= m_pMappings[dw].m_mtTime && m_pMappings[dw].m_mtTime <= mtNow) )
                                {
                                        DMUS_MUTE_PARAM MD;
                                        MUSIC_TIME mtNext = 0;
                                        MD.dwPChannel = m_pPatternTrack->m_pdwPChannels[dw];
                                        if (fClockTime)
                                        {
                                                MUSIC_TIME mtMusic;
                                                REFERENCE_TIME rtTime = (mtNow + mtOffset) * 10000;
                                                pPerformance->ReferenceToMusicTime(rtTime,&mtMusic);
                                                hr = pPerformance->GetParam(GUID_MuteParam, m_dwGroupID, DMUS_SEG_ANYTRACK, mtMusic,
                                                                                                        &mtNext, (void*) &MD);
                                                if (SUCCEEDED(hr))
                                                {
                                                        REFERENCE_TIME rtNext;
                                                        // Convert to absolute reference time.
                                                        pPerformance->MusicToReferenceTime(mtNext + mtMusic,&rtNext);
                                                        rtNext -= (mtOffset * 10000);   // Subtract out to get the time from segment start.
                                                        m_pMappings[dw].m_mtTime = (MUSIC_TIME)(rtNext / 10000);  // Convert to milliseconds. Could be problematic if there's a tempo change.
                                                        m_pMappings[dw].m_dwPChannelMap = MD.dwPChannelMap;
                                                        m_pMappings[dw].m_fMute = MD.fMute;
                                                }
                                                else
                                                {
                                                        // If we fail, disable mapping
                                                        m_pMappings[dw].m_mtTime = -1;
                                                        m_pMappings[dw].m_dwPChannelMap = m_pPatternTrack->m_pdwPChannels[dw];
                                                        m_pMappings[dw].m_fMute = FALSE;
                                                }
                                        }
                                        else
                                        {
                                                hr = pPerformance->GetParam(GUID_MuteParam, m_dwGroupID, DMUS_SEG_ANYTRACK, mtNow + mtOffset,
                                                                                                        &mtNext, (void*) &MD);
                                                if (SUCCEEDED(hr))
                                                {
                                                        m_pMappings[dw].m_mtTime = (mtNext) ? (mtNext + mtNow) : 0;
                                                        m_pMappings[dw].m_dwPChannelMap = MD.dwPChannelMap;
                                                        m_pMappings[dw].m_fMute = MD.fMute;
                                                }
                                                else
                                                {
                                                        // If we fail, disable mapping
                                                        m_pMappings[dw].m_mtTime = -1;
                                                        m_pMappings[dw].m_dwPChannelMap = m_pPatternTrack->m_pdwPChannels[dw];
                                                        m_pMappings[dw].m_fMute = FALSE;
                                                }
                                        }
                                }
                        }
                }
        }

        
        BOOL MapPChannel(DWORD dwPChannel, DWORD& dwMapPChannel);

        HRESULT PlayParts(MUSIC_TIME mtStart, 
                                          MUSIC_TIME mtFinish,
                                          MUSIC_TIME mtOffset,
                                          REFERENCE_TIME rtOffset,
                                          MUSIC_TIME mtSection,
                                          IDirectMusicPerformance* pPerformance,
                                          DWORD dwPartFlags,
                                          DWORD dwPlayFlags,
                                          bool& rfReloop);

        void PlayPatternEvent(
                MUSIC_TIME mtNow,
                CDirectMusicEventItem* pEventItem, 
                DirectMusicTimeSig& TimeSig,
                MUSIC_TIME mtPartOffset, 
                MUSIC_TIME mtSegmentOffset, 
                REFERENCE_TIME rtOffset, 
                IDirectMusicPerformance* pPerformance,
                short nPart,
                DirectMusicPartRef& rPartRef,
                BOOL fClockTime,
                MUSIC_TIME mtPartStart,
        bool& rfChangedVariation);

        void BumpTime(
                CDirectMusicEventItem* pEvent, 
                DirectMusicTimeSig& TimeSig, 
                MUSIC_TIME mtOffset,
                MUSIC_TIME& mtResult)
        {
                if (pEvent != NULL)
                {
                        mtResult = TimeSig.GridToClocks(pEvent->m_nGridStart) + mtOffset;
                }
        }

        virtual DWORD Variations(DirectMusicPartRef& rPartRef, int nPartIndex);

        virtual BOOL PlayAsIs();

        DirectMusicTimeSig& PatternTimeSig()
        {
                return
                        (m_pPattern && m_pPattern->m_timeSig.m_bBeat != 0) ? 
                                m_pPattern->m_timeSig : 
                (m_pStyle != NULL ? m_pStyle->m_TimeSignature : (::DefaultTimeSig));
        }

        void SendTimeSigMessage(MUSIC_TIME mtNow, MUSIC_TIME mtOffset, MUSIC_TIME mtTime, IDirectMusicPerformance* pPerformance);

        short FindGroup(WORD wID);
        short AddGroup(WORD wID, WORD wCount, short m_nOffset);
        DMStyleStruct* FindStyle(MUSIC_TIME mtTime, MUSIC_TIME& rmtTime);

        MUSIC_TIME NotifyMeasureBeat(
                MUSIC_TIME mtStart, MUSIC_TIME mtEnd, MUSIC_TIME mtOffset, IDirectMusicPerformance* pPerformance, DWORD dwFlags);

        HRESULT InitVariationSeeds(long lBaseSeed);
        HRESULT RemoveVariationSeeds();
        long RandomVariation(MUSIC_TIME mtTime, long lModulus);
        virtual MUSIC_TIME PartOffset(int nPartIndex);
        HRESULT InitPattern(CDirectMusicPattern* pTargetPattern, MUSIC_TIME mtNow, CDirectMusicPattern* pOldPattern = NULL);

        // attributes
        PatternTrackInfo*                       m_pPatternTrack;        // This track state's parent track info
        IDirectMusicTrack*                      m_pTrack;                       // This track state's parent track
        DMStyleStruct*                          m_pStyle;               // The style struct for the current style
        IDirectMusicSegmentState*       m_pSegState;    // The segment state for a performance
        DWORD                                           m_dwVirtualTrackID; // The track's ID
        MUSIC_TIME                                      m_mtCurrentChordTime; // when the current chord began
        MUSIC_TIME                                      m_mtNextChordTime;      // when the next chord begins
        MUSIC_TIME                                      m_mtLaterChordTime;     // when the chord after the next chord begins
        DMUS_CHORD_PARAM                        m_CurrentChord;         // current chord
        DMUS_CHORD_PARAM                        m_NextChord;            // next chord
        CDirectMusicPattern*            m_pPattern;                     // currently playing pattern
        DWORD*                                          m_pdwPChannels;     // array of PChannels for the pattern (1 per part)
        BYTE*                                           m_pVariations;          // array of variations (1 per part)
        DWORD*                                          m_pdwVariationMask;     // array of disabled variations (1 per part)
        DWORD*                                          m_pdwRemoveVariations;  // array of variations already played (1 per part)
        MUSIC_TIME*                                     m_pmtPartOffset;        // array of part offsets (1 per part)
    bool*                       m_pfChangedVariation; // array: have this part's variations changed?
        BOOL                                            m_fNewPattern;          // TRUE if we're starting a new pattern
        BOOL                                            m_mtPatternStart;       // Time the current pattern started
    BOOL                        m_fStateActive;
//    BOOL                        m_fStatePlay;
        InversionGroup                          m_aInversionGroups[INVERSIONGROUPLIMIT];
        short                                           m_nInversionGroupCount;
        MuteMapping*                            m_pMappings;            // dynamic array of PChannel mappings
                                                                                                        // (sized to # of PChannels)
        BYTE                                            m_abVariationGroups[MAX_VARIATION_LOCKS];
        CDirectMusicEventItem**         m_ppEventSeek;          // dynamic array of event list seek pointers
        DWORD                                           m_dwGroupID;            // Track's group ID
        CRandomNumbers*                         m_plVariationSeeds;     // dynamic array of random # generators (1 per beat)
        int                                                     m_nTotalGenerators; // size of m_plVariationSeeds
        DWORD                                           m_dwValidate; // used to validate state data
        HRESULT                                         m_hrPlayCode;  // last HRESULT returned by Play
        IDirectMusicPerformance*        m_pPerformance; // performance used to init the state data
        MUSIC_TIME                                      m_mtPerformanceOffset; // from track::play
        
};

const int CURVE_TYPES = 258; // one for each CC, one for each PAT, one for PB, one for MAT

class CurveSeek
{
public:
        CurveSeek();
        void AddCurve(CDirectMusicEventItem* pEvent, MUSIC_TIME mtTimeStamp);
        void PlayCurves(
                PatternTrackState* pStateData,
                DirectMusicTimeSig& TimeSig,
                MUSIC_TIME mtPatternOffset, 
                MUSIC_TIME mtOffset, 
                REFERENCE_TIME rtOffset,
                IDirectMusicPerformance* pPerformance,
                short nPart,
                DirectMusicPartRef& rPartRef,
                BOOL fClockTime,
                MUSIC_TIME mtPartStart);
private:
        CDirectMusicEventItem* m_apCurves[CURVE_TYPES];
        MUSIC_TIME m_amtTimeStamps[CURVE_TYPES];
        bool m_fFoundCurve;
};

#endif //__PATTERNTRACK_H_