/*====================================================================
 * transport.c
 *
 * Copyright 1995, Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics,
 * Inc.; the contents of this file may not be disclosed to third
 * parties, copied or duplicated in any form, in whole or in part,
 * without the prior written permission of Silicon Graphics, Inc.
 *
 * RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to
 * restrictions as set forth in subdivision (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS
 * 252.227-7013, and/or in similar or successor clauses in the FAR,
 * DOD or NASA FAR Supplement. Unpublished - rights reserved under the
 * Copyright Laws of the United States.
 *====================================================================*/

/*========================*/

#include <ultra64.h>
#include <ultralog.h>
#include <os.h>

#include <assert.h>
#include "music.h"
#include "audio.h"
#include "gfx.h"
#include "transport.h"
#include "UIpane.h"
#include "sequence.h"
#include "performance.h"
#include "font_ext.h"

#include "rew_sprite.h"
#include "stop_sprite.h"
#include "play_sprite.h"
#include "fwd_sprite.h"
#include "cuef_sprite.h"
#include "cueb_sprite.h"
#include "lpen_sprite.h"
#include "autoq_sprite.h"


static Transport        sTransport;

static void __XptItemInit (UIItem *pItem, int id);
static void __XptBtnDrawProc (UIItem *pItem, Gfx **ppGfx);

static void __XptPaneDrawProc (UIPane *pPane, Gfx **ppGfx);
static char __XptHandleEventProc (UIPane *pPane, UIEvent *pEvent);

static char __XptHandleMouseDown (UIPane *pPane, Point *pPt);
static char __XptHandleMouseUp (UIPane *pPane, Point *pPt);
static char __XptHandleButtonDown (UIPane *pPane, int button);

static void __XptDrawCounterProc (UIItem *pItem, Gfx **ppGfx);
static void __XptDrawCounterStr (UIItem *pItem, Gfx **ppGfx);

static void __GetRealTimeStr (char *pStr);
static void __GetMidiTimeStr (char *pStr);

static void __UpdateSelectedItems (void);

#define NUM_COUNTER_STR_BMS		9

static Bitmap CounterStrBM[NUM_COUNTER_STR_BMS];

static Gfx CounterStrDL[NUM_DL(NUM_COUNTER_STR_BMS)];

static Sprite CounterStrSprite = {
        0,0,                 /* Position: x,y */
        0,0,                 /* Sprite size in texels (x,y) */
        1.0,1.0,             /* Sprite Scale: x,y */
        0,0,                 /* Explosion (x,y) */
        SP_TRANSPARENT,      /* Sprite Attributes */
        0x1234,              /* Sprite Depth: Z */
        255,255,255,255,     /* Sprite Coloration: RGBA */
        0,0,NULL,            /* Color LookUp Table: start_index, length, address */
        0,1,                 /* Sprite Bitmap index: start index, step increment */
        NUM_COUNTER_STR_BMS,     /* Number of bitmaps */
        NUM_DL(NUM_COUNTER_STR_BMS), /* Number of display list locations allocated */
        15, 128,             /* Sprite Bitmap Height: Used_height, physical height */
        G_IM_FMT_I,          /* Sprite Bitmap Format */
        G_IM_SIZ_4b,         /* Sprite Bitmap Texel Size */
        CounterStrBM,      /* Pointer to bitmaps */
        CounterStrDL,      /* Display list memory */
        CounterStrDL,      /* HACK: dynamic_dl pointer */

};



void
Xpt_Init (UIPane **ppPane)
{
    UIItem      *pItem;
    int         i;

    /* Initialize transport specific fields. */
    sTransport.fState = kStopped;
    sTransport.fCounterUnits = kMidiTime;
    sTransport.fIsLooping = FALSE;
    sTransport.fAutoCue = FALSE;

    /* Initialize the transport's pane. */
    Pane_Init (&sTransport.fPane);
    sTransport.fPane.numItems = kNumXptItems;
    sTransport.fPane.itemList = sTransport.fItemList;
    sTransport.fPane.pData = &sTransport;
    sTransport.fPane.DrawProc = __XptPaneDrawProc;
    sTransport.fPane.HandleEventProc = __XptHandleEventProc;
        
    SetRect (&sTransport.fPane.bounds, kXpt_l, kXpt_t, kXpt_l + kXpt_w, kXpt_t + kXpt_h);
    

    /* Initialize each of the transport's pane's items. */
    for (i=0; i<sTransport.fPane.numItems; i++)
    {
        pItem = &sTransport.fPane.itemList[i];

        __XptItemInit (pItem, i);
    }

    /* Return the pane's address to the caller. */
    *ppPane = &sTransport.fPane;
}


static void
__XptItemInit (UIItem *pItem, int id)
{
    Item_Init (pItem, id);
    
    pItem->pPane = &sTransport.fPane; 
    pItem->DrawProc = __XptBtnDrawProc;

    switch (id)
    {
      case kRewItemID:
          SetRect (&pItem->bounds, kRewItem_l, kXptBtn_t, kRewItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &rew_sprite;
          break;

      case kStopItemID:
          SetRect (&pItem->bounds, kStopItem_l, kXptBtn_t, kStopItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &stop_sprite;
          break;

      case kPlayItemID:
          SetRect (&pItem->bounds, kPlayItem_l, kXptBtn_t, kPlayItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &play_sprite;
          break;

      case kFwdItemID:
          SetRect (&pItem->bounds, kFwdItem_l, kXptBtn_t, kFwdItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &fwd_sprite;
          break;

      case kCueBackItemID:
          SetRect (&pItem->bounds, kCueBackItem_l, kXptBtn_t, kCueBackItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &cueb_sprite;
          break;

      case kCueFwdItemID:
          SetRect (&pItem->bounds, kCueFwdItem_l, kXptBtn_t, kCueFwdItem_l + kXptBtn_w, kXptBtn_t + kXptBtn_h);
          pItem->pSpriteIcon = &cuef_sprite;
          break;

      case kCounterItemID:
          SetRect (&pItem->bounds, kCounterItem_l, kCounterItem_t, kCounterItem_l + kCounterItem_w, kCounterItem_t + kCounterItem_h);
          pItem->DrawProc = __XptDrawCounterProc;
          break;

      case kLoopEnableItemID:
          SetRect (&pItem->bounds, kLoopEnableItem_l, kLoopEnableItem_t, kLoopEnableItem_l + kMiniBtn_w, kLoopEnableItem_t + kMiniBtn_h);
	  pItem->pSpriteIcon = &lpen_sprite;
	  break;

      case kAutoCueItemID:
          SetRect (&pItem->bounds, kAutoCueItem_l, kAutoCueItem_t, kAutoCueItem_l + kMiniBtn_w, kAutoCueItem_t + kMiniBtn_h);
	  pItem->pSpriteIcon = &autoq_sprite;	  
    }

}


void
Xpt_Fini (void)
{}


void
Xpt_Play (void)
{
    if (sTransport.fState != kPlaying)
    {
        sTransport.fState = kPlaying;

        Perf_ClearStats ();
        Seq_Start ();

        PRINTF("Play.\n");
    }    
}



void
Xpt_Stop (void)
{
    if (sTransport.fState != kStopped)
    {
        sTransport.fState = kStopped;
        Seq_Stop ();

        PRINTF ("Stop.\n");
    }
}


/*
  This routine gets called when the end of the sequence is reached.
  Depending on the value of fAutoCue it will either cue up and play
  the next sequence or stop and rewind the current sequence.
*/
void
Xpt_AutoStop (void)
{
    if (sTransport.fAutoCue)
    {
	Xpt_CueForward ();
    }
    else
    {
	Xpt_Stop ();        /* The lower-level seqp should be stopped but this will also update our state variables. */
	Xpt_RTZ ();         /* Return auto-stopped sequence to beginning of sequence since there's nothing left to play. */
    }
}

    
void
Xpt_RTZ (void)
{
    char wasPlaying;
    
    if (wasPlaying = (sTransport.fState == kPlaying))
        Xpt_Stop ();

    Seq_RTZ ();
    PRINTF("Rewind to zero.\n");

    if (wasPlaying)
        Xpt_Play ();
}


void
Xpt_FastForward (void)
{
    if (sTransport.fState == kPlaying)
    {
        sTransport.fState = kFastPlay;
        Seq_SetFastTempo ();

        PRINTF("Fast forward.\n");
    }
}

void
Xpt_NormalForward (void)
{
    if (sTransport.fState == kFastPlay)
    {
        sTransport.fState = kPlaying;
        Seq_SetNormalTempo ();

        PRINTF("Normal forward.\n");
    }
}


void
Xpt_CueBack (void)
{
    Xpt_Stop ();

    Seq_CueBack ();

    Xpt_Play ();
}


void
Xpt_CueForward (void)
{
    Xpt_Stop ();

    Seq_CueForward ();

    Xpt_Play ();
}


void
Xpt_SetLoopEnable (char enable)
{
        if (enable)
            Seq_SetLoop (480*6);
        else
            Seq_SetLoop (0);
}



/*

  Transport UI Procs

*/


static void
__XptPaneDrawProc (UIPane *pPane, Gfx **ppGfx)
{
    UIItem *    pItem;
    int         i;
    
    /* Draw transport window. */
    DrawBeveledRect (&pPane->bounds, FALSE, FALSE, ppGfx);

    /* Make sure all items are up-to-date (eg. does play button reflect the play state?). */
    __UpdateSelectedItems ();

    /* Draw the transports ui items. */
    for (i=0; i<pPane->numItems; i++) 
    {
        pItem = &pPane->itemList[i];

        pItem->DrawProc (pItem, ppGfx);
    }
}


static void
__XptBtnDrawProc (UIItem *pItem, Gfx **ppGfx)
{
    Rect        boundsRect;
    
    Item_GetScreenBounds (pItem, &boundsRect);

    /* Draw unselected buttons raised and selected buttons sunken. */
    DrawBeveledRect (&boundsRect, pItem->fIsClicked || pItem->fIsSelected, FALSE, ppGfx);

    /* If the button is selected, then shift the button down to animate a button press. */
    if (pItem->fIsClicked || pItem->fIsSelected)
        OffsetRect (&boundsRect, 0, 1);
    
    if (pItem->pSpriteIcon != NULL)
        DrawSpriteIcon (&boundsRect, pItem->pSpriteIcon, ppGfx);        
}


static char
__XptHandleEventProc (UIPane *pPane, UIEvent *pEvent)
{
    char isHandled = FALSE;

    switch (pEvent->type)
    {
      case kMouseDown:
          isHandled = __XptHandleMouseDown (pPane, &pEvent->where);
          break;

      case kMouseUp:
          isHandled = __XptHandleMouseUp (pPane, &pEvent->where);
          break;

      case kButtonDown:
          isHandled = __XptHandleButtonDown (pPane, pEvent->what);
          break;
    }

    return isHandled;
}


static char
__XptHandleMouseDown (UIPane *pPane, Point *pPt)
{
    UIItem *    pItem;
    char	isHandled = FALSE;
    
    if (Pane_ItemClicked (pPane, pPt, &pItem))
    {
        assert(pItem != NULL);
        
        pItem->fIsClicked = TRUE;
        
        switch (pItem->id)
        {
          case kFwdItemID:
              Xpt_FastForward ();
              break;
        }

	isHandled = TRUE;
    }

    return isHandled;
}


static char
__XptHandleMouseUp (UIPane *pPane, Point *pPt)
{
    UIItem *    pItem;
    char	isHandled = FALSE;

    if (Pane_ItemClicked (pPane, pPt, &pItem))
    {
        assert(pItem != NULL);

        if (pItem->fIsClicked)
        {
            pItem->fIsClicked = FALSE;
        
            switch (pItem->id)
            {
              case kRewItemID:
                  Xpt_RTZ ();
                  break;
          
              case kPlayItemID:
                  Xpt_Play ();
                  break;

              case kStopItemID:
                  Xpt_Stop ();
                  break;

              case kFwdItemID:
                  Xpt_NormalForward ();
                  break;
          
              case kCueBackItemID:
                  Xpt_CueBack ();
                  break;

              case kCueFwdItemID:
                  Xpt_CueForward ();
                  break;

              case kCounterItemID:
                  if (sTransport.fCounterUnits == kRealTime)
                      sTransport.fCounterUnits = kMidiTime;
                  else
                      sTransport.fCounterUnits = kRealTime;
                  break;

	      case kLoopEnableItemID:
		  sTransport.fIsLooping = !sTransport.fIsLooping;
		  pItem->fIsSelected = sTransport.fIsLooping;
		  Xpt_SetLoopEnable (sTransport.fIsLooping);
		  break;
		  
	      case kAutoCueItemID:
		  sTransport.fAutoCue = !sTransport.fAutoCue;
		  pItem->fIsSelected = sTransport.fAutoCue;
		  break;
            }
        }

	isHandled = TRUE;
    }

    return isHandled;
}


static char
__XptHandleButtonDown (UIPane *pPane, int button)
{
    if (button & CONT_START)
    {
	if (sTransport.fState == kStopped)
	    Xpt_Play ();
	else
	    Xpt_Stop ();
    }

    if (button & CONT_C)
	Xpt_RTZ ();

    if (button & CONT_E)
	Xpt_CueForward ();

    if (button & CONT_D)
	Xpt_CueBack ();

    return FALSE;
}


static void
__XptDrawCounterProc (UIItem *pItem, Gfx **ppGfx)
{
    Rect        boundsRect;
    
    Item_GetScreenBounds (pItem, &boundsRect);
    
    DrawBeveledRect (&boundsRect, TRUE, FALSE, ppGfx);
    
    __XptDrawCounterStr (pItem, ppGfx);    
}


static void
__XptDrawCounterStr (UIItem *pItem, Gfx **ppGfx)
{
    Gfx         *gp;
    char        str[10];
    
    gp = *ppGfx;

    font_init (&gp);

    /* font_set_transparent( 1 ); */

    font_set_font (kLettersFont);
    font_set_pos (pItem->bounds.left + pItem->pPane->bounds.left + 2, pItem->bounds.top + pItem->pPane->bounds.top + 2);
    font_set_color (0, 0, 0, 255);
    font_set_scale (1.0, 1.0);
    font_set_win (8, 1);

    if (sTransport.fCounterUnits == kRealTime)
        __GetRealTimeStr (str);

    else if (sTransport.fCounterUnits == kMidiTime)
        __GetMidiTimeStr (str);
    
    CounterStrSprite.rsp_dl_next = CounterStrSprite.rsp_dl;
    font_show_string (&gp, str, &CounterStrSprite);
    
    font_finish (&gp);

    *ppGfx = gp;
}


static void
__GetRealTimeStr (char *pStr)
{
    ALMicroTime usecs;
    u32         minutes, seconds, hundreths;

    usecs = Seq_GetCurUSecs ();

    minutes = usecs/60000000;
    seconds = (usecs/1000000)%60;
    hundreths = (usecs/10000 - (minutes*60 + seconds)*100);
    
    sprintf (pStr, "%02d:%02d.%02d", minutes, seconds, hundreths);
}

static void
__GetMidiTimeStr (char *pStr)
{
    s32 ticks;

    ticks = Seq_GetCurTicks ();

    sprintf (pStr, "%07ld", ticks);
}


void
__UpdateSelectedItems (void)
{
    sTransport.fItemList[kPlayItemID].fIsSelected = sTransport.fState != kStopped;
}