#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include "etcache.h"
#include "blend.h"
#include "accesscache.h"
#include "easygene.h"
#include "easygraph.h"
#include "easycolor.h"
#include "easyTrackCache.h"
#include "et_parser.h"

/* EasyTrackCacheシステムを使用可能にする。                                 */
/* 戻り値  0:失敗  1:成功                                                   */
/* 副作用  データベースに接続する。既に接続している場合は何もしない。       */
int initEasyTrackCache()
{
  /* デーモン化した場合に必要な関数。static link版では何もしない */
  return 1;
}

/* EasyTrackCacheシステムの使用を終了する。                                 */
/* 副作用  データベースとの接続を切る。                                     */
void termEasyTrackCache()
{
  /* デーモン化した場合に必要な関数。static link版では何もしない */
}

/* EasyGeneTrackを出力すべき最大の遺伝子数を設定する。                      */
/* getGeneDataを呼び出した時に、この値を超えて遺伝子がヒットした場合は      */
/* EasygGraphTrackを出力する。                                              */
/* 戻り値  0: 失敗,  0以外: 成功(実際に設定した数を返す)                    */
int setMaxNumberOfGene(int num)  /* 設定する最大遺伝子数 */
{
  if (num < 0 || num > MAX_ENTRY_NUM)
    return 0;
  max_gene_number = num;
  return max_gene_number;
}

/* EasyGeneTrackを出力すべき最大遺伝子数の現在の値を得る。                  */
int getMaxNumberOfGene()
{
  return max_gene_number;
}

/* EasyGraphTrackを出力するときのデータ縮小方法(blend)を設定する。          */
/* 戻り値  0: 失敗, 1: 成功                                                 */
/* 副作用  デフォルトのblendの値を変更する                                  */
int setGraphBlendPolicy(char *policy)  /* {"average", "mode", "min", "max"} */
{
  BLEND blend_enum;
  blend_enum = resolveBlend(policy);
  if (blend_enum != NOBLEND) {
    currentGraphBlend = blend_enum;
    return 1;
  } else
    return 0;
}

/* EasyGraphTrackの現在のデータ縮小方法(blend)を得る。                      */
/* 戻り値  0:NOBLEND, 1:average, 2:mode, 3:min, 4:max                       */
int getGraphBlendPolicy()
{
  return currentGraphBlend;
}

/* EasyColorTrackを出力するときのデータ縮小方法(blend)を設定する。          */
/* 戻り値  0: 失敗, 1: 成功                                                 */
/* 副作用  デフォルトのblendの値を変更する                                  */
int setColorBlendPolicy(char *policy)      /* {"average", "mode"}           */
{
  BLEND blend_enum;
  blend_enum = resolveBlend(policy);
  if (blend_enum == average || blend_enum == mode) {
    currentColorBlend = blend_enum;
    return 1;
  } else
    return 0;
}

/* EasyColorTrackの現在のデータ縮小方法(blend)を得る。                      */
/* 戻り値  0:NOBLEND, 1:average, 2:mode                                     */
int getColorBlendPolicy()
{
  return currentColorBlend;
}

/* 指定条件を満たす遺伝子情報を含むEasyGeneTrack/EasyGraphTrackを出力する。 */
/* 戻り値  1: 成功(EasyGeneTrackを出力)                                     */
/*         2: 成功(EasyGraphTrackを出力)                                    */
/*         0: 失敗                                                          */
/* 副作用  指定されたストリームにEasyGeneTrack/EasyGraphTrackを書き出す     */
int getGeneData(char *trackname,  /* 今回表示すべきEasyTrackの名前   */
                char *species,    /* 表示すべき種                    */
                char *revision,   /* 表示すべき種のリビジョン        */
                char *target,     /* 表示すべき対象                  */
                int  start,       /* 表示開始位置(0-origin)          */
                int  end,         /* 表示終了位置(0-origin)          */
                int  width,       /* 出力すべき画像幅の指標          */
                char *date,       /* 表示すべきEasyTrackの作成日付   */
                char *stream,     /* 出力先ストリーム(ファイル)名    */
                int  threshold,   /* EasyGraphTrackで出力する閾値（遺伝子数）*/
                int  bUseOptSelect,     /* 追加属性のSelect型で検索する */
                char *strOptSelect,     /* : 追加属性のSelect型の名前   */
                char *strOptSelectEle,  /* : 追加属性のSelect型の値     */
                int  bUseOptReal,    /* :   追加属性のReal型で検索する  */
                char *strOptReal,    /* : 追加属性のReal型の名前        */
                double optRealLower,    /* : 追加属性のReal型で下限値      */
                double optRealUpper     /* : 追加属性のReal型の上限値      */
		)
{
  int result;
  result = getEasyGeneOrGraphTrack
    (trackname, species, revision, target,
     start, end, width, date, stream, threshold,
     bUseOptSelect, strOptSelect, strOptSelectEle,
     bUseOptReal, strOptReal, optRealLower, optRealUpper);
  return result;
}

/* 指定範囲のデータを含むEasyGraphTrackを出力する。                         */
/* 戻り値  1: 成功, 0: 失敗                                                 */
/* 副作用  指定されたストリームにEasyGraphTrackを書き出す                   */
int getGraphData(char *trackname,  /* 今回表示すべきEasyTrackの名前   */
                 char *species,    /* 表示すべき種                    */
                 char *revision,   /* 表示すべき種のリビジョン        */
                 char *target,     /* 表示すべき対象                  */
                 int  start,       /* 表示開始位置(0-origin)          */
                 int  end,         /* 表示終了位置(0-origin)          */
                 int  width,       /* 出力すべき画像幅の指標          */
                 char *date,       /* 表示すべきEasyTrackの作成日付   */
                 char *blendname,  /* ブレンド方法                    */
                 char *stream)     /* 出力先ストリーム(ファイル)名    */
{
  EasyGraphTrack *egt;
  int result;
  BLEND gblend;

  connectCacheDB();
  egt = findEasyGraphTrack(trackname, species, revision, target, date);
  if (!egt) {
    egt = makeEasyGraphTrack(trackname, species, revision, date);
  }
  if (!egt) {
    fprintf(stderr, "*** failed to find EasyGraphTrack\n");
    return 0;
  }
  gblend = resolveBlend(blendname);
  if (gblend == NOBLEND)
    gblend = currentGraphBlend;
  result = outputGraphCache(egt, stream, start, end, width, gblend);
  destroyEasyGraphTrack(&egt);
  disconnectCacheDB();
  return result;
}

/* 指定範囲のデータを含むEasyColorTrackを出力する。                         */
/* 戻り値  1: 成功, 0: 失敗                                                 */
/* 副作用  指定されたストリームにEasyColorTrackを書き出す                   */
int getColorData(char *trackname,  /* 今回表示すべきEasyTrackの名前   */
                 char *species,    /* 表示すべき種                    */
                 char *revision,   /* 表示すべき種のリビジョン        */
                 char *target,     /* 表示すべき対象                  */
                 int  start,       /* 表示開始位置(0-origin)          */
                 int  end,         /* 表示終了位置(0-origin)          */
                 int  width,       /* 出力すべき画像幅の指標          */
                 char *date,       /* 表示すべきEasyTrackの作成日付   */
                 char *blendname,  /* ブレンド方法                    */
                 char *stream)     /* 出力先ストリーム(ファイル)名    */
{
  EasyColorTrack *ect;
  int result;
  BLEND cblend;

  connectCacheDB();
  ect = findEasyColorTrack(trackname, species, revision, target, date);
  if (!ect) {
    fprintf(stderr, "*** failed to find EasyColorTrack\n");
    return 0;
  }
  cblend = resolveBlend(blendname);
  if (cblend == NOBLEND)
    cblend = currentColorBlend;
  result = outputColorCache(ect, stream, start, end, width, cblend);
  destroyEasyColorTrack(&ect);
  disconnectCacheDB();
  return result;
}

/* 現在DBに格納されている遺伝子データからCacheファイルを作成する           */
/* 戻り値  1: 成功, 0: 失敗                                                */
int createGraphCacheFile(char *name, char *species, char *revision,
                         char *target, char *path)
{
  if (!path) {
    path = assembleCacheFileName(name, species, revision, target,
                                 path, PATH_MAX_LEN + 1);
  }
  return createGraphData(name, species, revision, target, path);
}

/**************************************************************************/
/* EasyTrackファイルを指定して、その内容をデータベースに登録する          */
/* EasyGraphTrackの場合はキャッシュファイルも作成する                     */
/*   戻り値  1:成功   0:失敗                                              */
/**************************************************************************/
int addEasyTrack(char *path)
{
  FILE *fp;
  char *buf;
  ET_TYPE ettype;
  EasyGeneTrack  *geneTrack = NULL;
  EasyGraphTrack *graphTrack = NULL;
  EasyColorTrack *colorTrack = NULL;
  EasyGraph  *graph = NULL;
  EasyColor  *color = NULL;
  char cachepath[PATH_MAX_LEN + 1];
  int genenum = 0;
  int graphnum = 0;
  int colornum = 0;
  int lineno = 0;
//  int bad_genenum = 0;
  int bad_graphnum = 0;
  int bad_colornum = 0;
  int result = 0;
  int stopflag = 0;

  /* EasyTrackファイルを開く */
  fp = fopen(path, "r");
  if (!fp) {
    fprintf(stderr, "addEasyTrack: cannot open file: %s\n", path);
    return 0;
  }

  /* キャッシュ登録用DB(cachefiles)に接続する */
  result = connectCacheDB();
  if (!result) {
    fprintf(stderr, "addEasyTrack: db connection is failed.\n");
    return result;
  }

  /* EasyTrackファイルの各行をパースする */
  while (!stopflag && vfgets(&buf, fp)) {
    lineno++;
    ettype = identify_line(buf);
    switch (ettype) {
    case et_geneTrack:
      geneTrack = parse_geneTrack_line(buf);
      break;
    case et_graphTrack:
      graphTrack = parse_graphTrack_line(buf);
      createDirectories(graphTrack);
      break;
    case et_colorTrack:
      colorTrack = parse_colorTrack_line(buf);
      result = addEasyColorTrackToDB(colorTrack);
      if (!result)
        fprintf(stderr, "adding EasyColroTrack to DB is failed.\n");
      break;
    case et_gene:
      genenum++;
      fprintf(stderr, "-- %d gene lines are registered.\n", genenum);
      break;
    case et_graph:
      if (!graphTrack) {
        fprintf(stderr, "addEasyTrack: graph line precedes graphTrack line.\n");
        stopflag = 1;
        break;
      }
      graph = parse_graph_line(buf);
      if (!graph) {
        fprintf(stderr, "addEasyTrack: failed to parse graph line.\n");
        break;  /* 変な行は無視して次の行へ進む */
      }
      result = addEasyGraphToDB(graphTrack, graph);
      if (result) {
        assembleCacheFileName(graphTrack->name, graphTrack->species,
                              graphTrack->revision, graph->target,
                              cachepath, PATH_MAX_LEN + 1);
//fprintf(stderr, "PATH:%s\n", cachepath);
        writeGraphValue(graph, cachepath);
        graphnum++;
        if (graphnum % 1000 == 0)
          fprintf(stderr, "-- %d graph lines are registered.\n", graphnum);
      } else {
        bad_graphnum++;
        fprintf(stderr, "!! %d graph lines are invalid.\n", bad_graphnum);
      }
      destroyEasyGraph(&graph);
      break;
    case et_color:
      if (!colorTrack) {
        fprintf(stderr, "addEasyTrack: color line precedes colorTrack line.\n");
        stopflag = 1;
        break;
      }
      color = parse_color_line(buf);
      if (!color) {
        fprintf(stderr, "addEasyTrack: failed to parse color line.\n");
        break;  /* 変な行は無視して次の行へ進む */
      }
//dumpEasyColor(stderr, color);
      result = addEasyColorToDB(colorTrack, color);
      if (result) {
        colornum++;
        if (colornum % 1000 == 0)
          fprintf(stderr, "-- %d color lines are registered.\n", colornum);
      } else {
        bad_colornum++;
        fprintf(stderr, "!! %d color lines are invalid.\n", bad_colornum);
      }
      destroyEasyColor(&color);
      break;
    default:
      /* 警告だけ出して次の行へ進む */
      fprintf(stderr, "addEasyTrack: line %d is invalid. (ignored)\n", lineno);
    }
    if (buf) {
      free(buf); onmemStrings--; /* String */
      buf = NULL;
    }
  }
  if (geneTrack) {
    ;
  }
  if (graphTrack) {
    destroyEasyGraphTrack(&graphTrack);
    fprintf(stderr, "%d graphs are registered.\n", graphnum);
  }
  if (colorTrack) {
    destroyEasyColorTrack(&colorTrack);
    fprintf(stderr, "%d colors are registered.\n", colornum);
  }
  if (shared_area) {
    free(shared_area); onmemSharedArea--; /* SharedArea */
    shared_area_size = 0;
  }
  disconnectCacheDB();
  return 1;
}