// Copyright 2011 Google Inc. All Rights Reserved.
// Author: qianzhang@google.com (Qian Zhang)

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <inttypes.h>
#include <assert.h>
#include "utility.h"
#include "hdhomerun_plugin.h"
#include "libhdhomerun/hdhomerun.h"
#include "hdhomerun_tuner.h"
#include "hdhomerun_dev.h"
#include "hdhomerun_tuner.h"
#include "channel_buffer.h"
#include "sagelog.h"

#define MAX_TUNER_NUM 16

struct device_list {
  int tuner_num;
  int list_num;
  struct hdhr_tuner_t *hdhrs;
};

static int discover_hdhrs( struct hdhr_tuner_t *ht, int max_ht_num )
{
  int  i, ret = 0 ;
  ret = discover_device( ht, max_ht_num );
  if ( ret > 0 ) {
    for ( i = 0; i<ret; i++ ) {
      //if a unit shares a source input in a device, copy data.
      if ( i> 0 && tuner_input_sharing( &ht[i-1], &ht[i] ) ) {
        ht[i].cc_tuner = ht[i-1].cc_tuner;
        strncpy( ht[i].model, ht[i-1].model, sizeof(ht[i].model) );
      } else
        get_dev_model( &ht[i] );
    }
    return i;
  }
  return 0;
}

void* dev_init( int *num )
{
  int i, index = 0, tuner_num;
  struct device_list *devices;

  sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun device init"));

  devices = (struct device_list *)malloc( sizeof(struct device_list) );
  if ( devices != NULL ) {
    devices->hdhrs = (struct hdhr_tuner_t *)malloc(sizeof(struct hdhr_tuner_t) * MAX_TUNER_NUM );
    memset( devices->hdhrs, 0, sizeof(sizeof(struct hdhr_tuner_t) * MAX_TUNER_NUM) );
    if ( devices->hdhrs == NULL ) {
      free( devices);
      return 0;
    }
    devices->list_num = MAX_TUNER_NUM;
    devices->tuner_num = 0;
    tuner_num = discover_hdhrs( devices->hdhrs, MAX_TUNER_NUM );
    for ( i = 0; i<tuner_num; i++ ) {
      devices->hdhrs[i].tuner_id = index++;
      snprintf(devices->hdhrs[i].tuner_name,
               sizeof(devices->hdhrs[i].tuner_name), "%s-%s",
               devices->hdhrs[i].model, devices->hdhrs[i].name);
      devices->tuner_num++;
      sage_log((_LOG_TRACE, 3, "hdhr:%d %s %s %s", i,
                devices->hdhrs[i].tuner_name, devices->hdhrs[i].model,
                devices->hdhrs[i].cc_tuner ? "CableCard" : ""));
    }
    devices->tuner_num = tuner_num;
    *num = tuner_num;
    return devices;
  }
  return NULL;
}

void dev_release( void* handle )
{
  struct device_list *devices = (struct device_list *)handle;
  if ( devices != NULL ) {
    if ( devices->hdhrs != NULL )
      free( devices->hdhrs );
    free( devices );
  }
  sage_log(( _LOG_TRACE, 3,  "hdhr:hdhomerun device release." ));
}

int get_dev_name( void* handle, int index, char* name, int max_name_len  )
{
  struct device_list *devices = (struct device_list *)handle;
  if ( devices != NULL && index < devices->tuner_num ) {
    struct hdhr_tuner_t* hdhr = &devices->hdhrs[index];
    strncpy( name, hdhr->tuner_name, max_name_len );
    return 1;
  }
  return 0;
}

void* dev_open( void* handle, int index, int attr )
{
  struct device_list *devices = (struct device_list *)handle;
  struct hdhr_tuner_t* hdhr;
  if ( index >= devices->tuner_num )
    return NULL;
  hdhr = &devices->hdhrs[index];
  hdhr->hd = open_hdhr( hdhr->name );
  return hdhr;
}

void dev_close( void* dev )
{
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return;
  }
  stop_channel( hdhr->hd );
  close_hdhr( hdhr->hd );
}

int dev_tune( void* dev, char* channel, char* stream_tar )
{
  int ret;
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return 0;
  }
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", hdhr->name, (char*)channel ));
  if ( strstr( stream_tar, "udp://" ) == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: stream target \"%s\" is wrong.", stream_tar ));
    return 0;
  }

  if ( hdhr->cc_tuner ) {
    /* HDHomeRun PRIME */
    if ( strstr( channel, "vchan:" ) == NULL ) {
      char vchan[32];
      snprintf( vchan, sizeof(vchan), "vchan:%d", atoi(channel) );
      ret = tune_channel( hdhr->hd, vchan, "", stream_tar );
    } else
      ret = tune_channel( hdhr->hd, channel, "", stream_tar );
  } else {
    /* HDHomeRun US */
    char tune_str[32], map_str[32], prog_str[8];
    int ch = -1, prog = -1, vch_major = -1, vch_minor = -1;
    char *ps, *pe;
    map_str[0] = 0x0;

    /*
     * channel format: xx-yy-zz
     * xx=physical channel, yy=virtual major channel, zz=virtual minor channel
     */
    if (sscanf(channel, "%d-%d-%d", &ch, &vch_major, &vch_minor) == 3) {
      ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
      goto out;
    }

    /*
     * channel format: xx-yy
     * xx=physical channel, yy=virtual major channel
     */
    if (sscanf(channel, "%d-%d", &ch, &vch_major) == 2) {
      vch_minor = 0;
      ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
      goto out;
    }

    //if channel in format "map:xxx-yy|auto:zzz prog:ppp"
    if ( ( ps = strstr( channel, "map:" ))!= NULL &&
       ( pe = strchr( ps+4, '|' )) != NULL ) {
      strncpy( map_str, ps+4, pe-(ps+4) );
      map_str[pe-(ps+4)] = 0x0;
    }
    get_int_val_by_name( channel, "auto", &ch, NULL );
    get_int_val_by_name( channel, "prog", &prog, NULL );
    if ( prog == -1 ) {
      sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid channel string %s", channel ));
      return 0;
    }
    //if channel in format "nnn prog:mmm", based on dev to guess map
    if ( map_str[0] == 0x0 && prog > 0 && ch == -1 ) {
      ch=atoi( channel );
      if ( ch > 0 ) {
        snprintf( map_str, sizeof(map_str), "map:us-bcast" );
      }
    }
    if ( map_str[0] && ch > 0 && prog > 0 ) {
      snprintf( tune_str, sizeof(tune_str), "%s|auto:%d", map_str, ch );
      snprintf( prog_str, sizeof(prog), "%d", prog );
      ret = tune_channel( hdhr->hd, tune_str, prog_str, stream_tar );
    } else {
      sage_log(( _LOG_ERROR, 3, "hdhr:ERROR: invalid channel string %s", channel ));
      return 0;
    }
  }

out:
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", (char*)channel, ret>0?"successful":"failed" ));
  return ret > 0;
}

int dev_stop( void* dev )
{
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
     sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return 0;
  }
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun stop %s.", (char*)hdhr->name ));
  int ret = stop_channel( hdhr->hd );
  return ret > 0;
}

int dev_scan( void* dev, char* tuner_name, char* channel, struct channel_list_t **cl_p )
{
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return 0;
  }
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun scan %s.", (char*)hdhr->name ));
  if ( hdhr->cc_tuner ) {
    int vchannel;
    char *p;
    if ( ( p = strstr( channel, "vchan:" ) ) == NULL )
      vchannel = atoi(channel) ;
    else
      vchannel = atoi(p+6);
    if ( vchannel == 0 )
      return 0;

    struct channel_list_t *cl = _create_channel_list( 1 );
    int ret = scan_vchannel( hdhr->hd, vchannel, cl->ce );
    char unit_name[16];
    snprintf( cl->ce[0].dev_name, sizeof(cl->ce[0].dev_name)-1, "HDHR.%s", get_unit_name( hdhr, unit_name, sizeof(unit_name) ));
    cl->channel_num = ret;
    if ( ret == 0 ) {
      _release_channel_list( cl );
      cl = NULL;
    }
    if ( cl_p != NULL )
      *cl_p = cl;
    return ret;
  } else {
    sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun ATSC dev_scan not implemented %s.",
              (char*)hdhr->name));
  }

  return 0;
}

static struct channel_list_t * build_hdhr_channel_table(  struct hdhr_tuner_t* hdhr )
{
  if ( hdhr->cc_tuner ) {
    struct vchan_tbl_t* vt = create_vchan_tbl( hdhr );
    struct channel_list_t *cl = NULL;
    if ( get_vchannel_list( vt ) > 0 ) {
      int num = vt->channel_num;
      cl = _create_channel_list( num );
      int i;
      for ( i = 0; i<num; i++ ) {
        char unit_name[16];
        cl->ce[i].state = 1;
        snprintf( cl->ce[i].dev_tuning, sizeof(cl->ce[i].dev_tuning)-1, "vchan:%d", vt->vchan[i].guide_id );
        snprintf( cl->ce[i].ch_name, sizeof(cl->ce[i].ch_name)-1, "%d", vt->vchan[i].guide_id );
        strncpy( cl->ce[i].ch_desc, vt->vchan[i].guide_name, sizeof(cl->ce[i].ch_desc)-1 );
        cl->ce[i].src_ip[0] = 0x0;
        cl->ce[i].src_port = 0;    //dynamic assigning
        snprintf( cl->ce[i].dev_name, sizeof(cl->ce[i].dev_name)-1, "HDHR.%s", get_unit_name( hdhr, unit_name, sizeof(unit_name) ));
        cl->ce[i].ch = vt->vchan[i].guide_id;
        cl->ce[i].frq = 0;
        cl->ce[i].av_inf[0] = 0;
      }
      cl->channel_num = i;
    }
    release_vchan_tbl( vt );
    return cl;
  } else {
    sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun ATSC build_hdhr_channel_table not implemented %s.",
              (char*)hdhr->name));
  }
  return NULL;
}

int dev_build_channel_table( void* dev, char* option, struct channel_list_t **cl_p )
{
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return 0;
  }
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun dev_build_channel_table %s.", (char*)hdhr->name ));
  struct channel_list_t *cl= build_hdhr_channel_table( hdhr );
  if ( cl_p != NULL ) {
    *cl_p = cl;
    if ( cl == NULL )
      return 0;
    return cl->channel_num;
  }
  return 0;
}

int dev_release_channel_table( void* dev )
{
  struct hdhr_tuner_t* hdhr = (struct hdhr_tuner_t*)dev;
  if ( hdhr == NULL ) {
    sage_log(( _LOG_TRACE, 3, "hdhr:ERROR: invalid device handle." ));
    return 0;
  }
  sage_log(( _LOG_TRACE, 3, "hdhr:hdhomerun dev_release_channel_table %s.", (char*)hdhr->name ));
  if ( hdhr->channel_table != NULL ) {
    free( hdhr->channel_table );
    hdhr->channel_table = NULL;
    return 1;
  } else {  //TODO

  }
  return 0;
}