/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/04/09 11:49a   $       ****************/
/***************  $Revision:: 3                $       ****************/
/***************                                       ****************/
/***************   Description : Program State         ****************/
/***************                 Machine               ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Sung-Ching Lin        ****************/
/**********************************************************************/

#include "general.h"

#pragma NOAREGS

#ifdef PLAYER_PROGRAM

#define PROGRAM_KEY_EXIT
#define PROGRAM_STOP_CLEAR

// *********************************************************************
// Local Define
// *********************************************************************
/* for program state */
enum {
  PROG_STATE_EXIT,
  PROG_STATE_SELECT,
  PROG_STATE_PREV,
  PROG_STATE_NEXT,
  PROG_STATE_START_STOP,
  PROG_STATE_INPUT,
  PROG_STATE_INPUT_1
};

#define PROG_ITEM_TYPE_TIME     0
#define PROG_ITEM_TYPE_TT_CH    1

typedef struct structSelMenu
{
  /* BYTE 1 */
  BYTE bState:3;
  BYTE bHili:4;
  BYTE bPage:1;
  /* BYTE 2 */
  BYTE bSelNoValid:4;
  BYTE fgPrevValid:1;
  BYTE fgNextValid:1;
  BYTE fgExitValid:1;
  BYTE fgStartStopValid:1;
  /* BYTE 3 */
  BYTE bItemType:1;
  BYTE fgWaitProgStop:1;
  BYTE fgListValid:1;
  BYTE bReserve:5;
  /* BYTE 4 */
  BYTE bSelNoMax;
} strucSelMenu;

static xdata strucSelMenu _rSelMenu;

static code BYTE pbSelMenuHiliState[14] = {
  PROG_STATE_SELECT,      /*  0 */
  PROG_STATE_SELECT,      /*  1 */
  PROG_STATE_SELECT,      /*  2 */
  PROG_STATE_SELECT,      /*  3 */
  PROG_STATE_SELECT,      /*  4 */
  PROG_STATE_SELECT,      /*  5 */
  PROG_STATE_SELECT,      /*  6 */
  PROG_STATE_SELECT,      /*  7 */
  PROG_STATE_SELECT,      /*  8 */
  PROG_STATE_SELECT,      /*  9 */
  PROG_STATE_PREV,        /* 10 */
  PROG_STATE_EXIT,        /* 11 */
  PROG_STATE_START_STOP,  /* 12 */
  PROG_STATE_NEXT         /* 13 */
};

#define bSelMenuHiliState(bHili) (pbSelMenuHiliState[bHili])

#ifdef HILI_USE_OSD
BYTE _bSelMenuFromStop;
#endif /* HILI_USE_OSD */
// *********************************************************************
// Macros
// *********************************************************************
BYTE bSelMenuHiliItemNo(BYTE bPage, BYTE bHili) large
{
  BYTE bSelNo;

  bSelNo = bPage * SELMENU_PAGE_SIZE;

  if (bHili >= SELMENU_PAGE_SIZE)
  {
    bSelNo += (SELMENU_PAGE_SIZE - 1);
  }
  else
  {
    bSelNo += bHili;
  }
  
  return (bSelNo);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vSelMenuReset(void) large
{
  vSetSharedInfo(SI_USR_PROGRAM_TYPE, SV_PROGRAM_NONE_ITEM);
  /* vSetSharedInfo(SI_USR_PROGRAM_NO, 0); */
  vSetSharedInfo(SI_USR_PROGRAM_NS, 0);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BYTE bSelMenuReadItem(BYTE bItemIdx, BYTE *pbTime) large
{
  if (bItemIdx >= SV_PROGRAM_MAX_ITEM)
  {
    return (0);
  }

  if (pbTime != 0)
  {
    pbTime[0] = bSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 1);
    pbTime[1] = bSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 2);
    pbTime[2] = bSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 3);
  }

  return (bSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE));
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static void vSelMenuSetItem(BYTE bItemIdx, BYTE bSelNo, BYTE *pbTime) large
{
  if (bItemIdx >= SV_PROGRAM_MAX_ITEM)
  {
    return;
  }

  vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE, bSelNo);

  if (pbTime != 0)
  {
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 1, pbTime[0]);
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 2, pbTime[1]);
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 3, pbTime[2]);
  }
  else
  {
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 1, 0);
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 2, 0);
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + bItemIdx * SV_PROGRAM_ITEM_SIZE + 3, 0);
  }

  
  /* notify here ? */
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static void vSelMenuResetItem(void) large
{
  BYTE i;

  vSetSharedInfo(SI_USR_PROGRAM_NS, 0);
  vSetSharedInfo(SI_USR_PROGRAM_NO, 0);

  for (i = 0; i < SV_PROGRAM_MAX_ITEM; i++)
  {
    /* clear all item's slected number to 0 */
    vSetSharedInfo(SI_USR_PROGRAM_ITEM_1 + i * SV_PROGRAM_ITEM_SIZE, 0);
  }

  _rSelMenu.fgListValid = FALSE;
}

// *********************************************************************
// Function : void vSelMenuShowBar(void) large
// Description :
// Parameter : 
// Return    : None
// Note      : 
// *********************************************************************
static void vSelMenuShowBar(void) large
{
  BYTE bStartStop;

  if (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM)
  {
    bStartStop = SV_PROGRAM_STOP;
  }
  else
  {
    bStartStop = SV_PROGRAM_START;
  }

  vOsdPosPaste(OSD_POS_PROG_BAR_2, OSD_MSG_EXIT);
#ifdef HILI_USE_OSD
  if (_bSelMenuFromStop == 0x77 && !_rSelMenu.fgListValid)
  {
	  vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_BAR_2, 0);
	  _bSelMenuFromStop = 0;
  }
#endif /* HILI_USE_OSD */
  _rSelMenu.fgExitValid = TRUE; /* always valid */
  
  if (_rSelMenu.bPage > 0)
  {
    vOsdPosPaste(OSD_POS_PROG_BAR_1, OSD_MSG_PREV_PAGE);
    _rSelMenu.fgPrevValid = TRUE;
  }
  else
  {
    vOsdPosClear(OSD_POS_PROG_BAR_1);
    _rSelMenu.fgPrevValid = FALSE;
  }

  if (_rSelMenu.bPage < SELMENU_PAGE_NS - 1)
  {
    vOsdPosPaste(OSD_POS_PROG_BAR_4, OSD_MSG_NEXT_PAGE);
    _rSelMenu.fgNextValid = TRUE;
  }
  else
  {
    vOsdPosClear(OSD_POS_PROG_BAR_4);
    _rSelMenu.fgNextValid = FALSE;
  }

  vOsdPosClear(OSD_POS_PROG_BAR_3);
  if ((bSharedInfo(SI_USR_PROGRAM_NS) > 0) &&
      (bSharedInfo(SI_USR_PROGRAM_TYPE) != SV_PROGRAM_NONE_ITEM))
  {
    if (bStartStop == SV_PROGRAM_START)
    {
      vOsdPosPaste(OSD_POS_PROG_BAR_3, OSD_MSG_START);
    }
    else /* if (bStartStop == SV_PROGRAM_STOP) */
    {
      vOsdPosPaste(OSD_POS_PROG_BAR_3, OSD_MSG_STOP);
    }
    _rSelMenu.fgStartStopValid = TRUE;
  }
  else
  {
    _rSelMenu.fgStartStopValid = FALSE;
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BYTE bSelMenuGetBarNextValid(BYTE bCurrState) large
{
  BYTE bState;
  
  switch (bCurrState)
  {
    case PROG_STATE_SELECT:
      if (_rSelMenu.fgPrevValid)
      {
        bState = PROG_STATE_PREV;
        break;
      }
    case PROG_STATE_PREV:
      if (_rSelMenu.fgExitValid)
      {
        bState = PROG_STATE_EXIT;
        break;
      }
    case PROG_STATE_EXIT:
      if (_rSelMenu.fgStartStopValid)
      {
        bState = PROG_STATE_START_STOP;
        break;
      }
    case PROG_STATE_START_STOP:
      if (_rSelMenu.fgNextValid)
      {
        bState = PROG_STATE_NEXT;
        break;
      }      
    case PROG_STATE_NEXT:
    default:
      bState = PROG_STATE_SELECT;
      break;
  }

  return (bState);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BYTE bSelMenuGetBarPrevValid(BYTE bCurrState) large
{
  BYTE bState;
  
  switch (bCurrState)
  {
    case PROG_STATE_SELECT:
      if (_rSelMenu.fgNextValid)
      {
        bState = PROG_STATE_NEXT;
        break;
      }
    case PROG_STATE_NEXT:
      if (_rSelMenu.fgStartStopValid)
      {
        bState = PROG_STATE_START_STOP;
        break;
      }
    case PROG_STATE_START_STOP:
      if (_rSelMenu.fgExitValid)
      {
        bState = PROG_STATE_EXIT;
        break;
      }
    case PROG_STATE_EXIT:
      if (_rSelMenu.fgPrevValid)
      {
        bState = PROG_STATE_PREV;
        break;
      }
    case PROG_STATE_PREV:
    default:
      bState = PROG_STATE_SELECT;
      break;
  }

  return (bState);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static void vSelMenuShowPage(BYTE bPageIdx, BYTE bHeader) large
{
  BYTE i;
  BYTE bTmp = bSharedInfo(SI_USR_PROGRAM_TYPE);
  BYTE pbTime[3];

  if (bPageIdx >= SELMENU_PAGE_NS)
  {
    return;
  }

  if (bHeader)
  {
    bHeader = OSD_PROG_ITEM_HEADER;
  }
  else
  {
    bHeader = OSD_PROG_ITEM_NORMAL;
  }

  if (bTmp == SV_PROGRAM_NONE_ITEM)
  {
    for(i = bPageIdx * SELMENU_PAGE_SIZE; i < (bPageIdx + 1) * SELMENU_PAGE_SIZE; i++)
    {
      if (_rSelMenu.bItemType == PROG_ITEM_TYPE_TT_CH)
      {
         vOsdShowProgItemTtCh(i, bHeader, 0, 0);
      }
      else /* if (_rSelMenu.bItemType == PROG_ITEM_TYPE_TIME) */
      {
        vOsdShowProgItemTime(i, bHeader, 0, 0);
      }
    }
  }
  else
  {
    for(i = bPageIdx * SELMENU_PAGE_SIZE; i < (bPageIdx + 1) * SELMENU_PAGE_SIZE; i++)
    {
      bTmp = bSelMenuReadItem(i, pbTime);
      
      if (_rSelMenu.bItemType == PROG_ITEM_TYPE_TT_CH)
      {
        if ((bTmp > 0) && (bTmp <= _rSelMenu.bSelNoMax) &&
            (pbTime[0] <= bSharedInfo(SI_DVD_TT_CH + bTmp - 1)))
        {
          vOsdShowProgItemTtCh(i, bHeader, bTmp, pbTime[0]);
        }
        else
        {
          vOsdShowProgItemTtCh(i, bHeader, 0, 0);
        }
      }
      else /* if (_rSelMenu.bItemType == PROG_ITEM_TYPE_TIME) */
      {
        if ((bTmp > 0) && (bTmp <= _rSelMenu.bSelNoMax))
        {
          if ((pbTime[0] <= 9) && (bBCDToHEX(pbTime[1]) <= 59) &&
                                  (bBCDToHEX(pbTime[2]) <= 59))
          {
            vOsdShowProgItemTime(i, bHeader, bTmp, pbTime);
          }
          else
          {
            vOsdShowProgItemTime(i, bHeader, bTmp, 0);
          }
        }
        else
        {
          vOsdShowProgItemTime(i, bHeader, 0, 0);
        }
      } /* _rSelMenu.bItemType */
    }
  }

  vSelMenuShowBar();
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static void vSelMenuGotoBar(BYTE bState) large
{ 
#ifdef HILI_USE_OSD
  // - Clear all item.
  vOsdPosHili(OSD_POS_HILI_CLEAR, OSD_POS_PROG_ITEM_1, 0);
#endif    
  switch (bState)
  {
    case PROG_STATE_EXIT:
      vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_BAR_2, 0);
      break;
    
    case PROG_STATE_PREV:
      vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_BAR_1, 0);
      break;

    case PROG_STATE_NEXT:
      vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_BAR_4, 0);
      break;

    case PROG_STATE_START_STOP:
      vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_BAR_3, 0);
      break;
          
    case PROG_STATE_SELECT:
    case PROG_STATE_INPUT:
    case PROG_STATE_INPUT_1:
    default:
      break;
  }

  _rSelMenu.bState = bState;
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static void vSelMenuGotoItem(BYTE bItemIdx) large
{
  BYTE bPage;
  
  if (bItemIdx >= (SELMENU_PAGE_SIZE * SELMENU_PAGE_NS))
  {
    return;
  }

  bPage = 0;

  while (bItemIdx >= SELMENU_PAGE_SIZE)
  {
    bItemIdx -= SELMENU_PAGE_SIZE;
    bPage++;
  }

  if (bPage != _rSelMenu.bPage)
  {
    _rSelMenu.bPage = bPage;
    vSelMenuShowPage(bPage, OSD_PROG_ITEM_HEADER); 
  }

  _rSelMenu.bHili = bItemIdx;
  #ifdef HILI_USE_OSD
  // - Clear all item.
  vOsdPosHili(OSD_POS_HILI_CLEAR, OSD_POS_PROG_ITEM_1, 0);
  #endif
  vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_PROG_ITEM_1 + bItemIdx, 0);

  _rSelMenu.bState = bSelMenuHiliState(_rSelMenu.bHili);
}

// *********************************************************************
// Function :
// Description :
// Parameter :