/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: GPL 2.0
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License. You should have
* received a copy of the GPL license along with this program; if you
* did not, you can find it at http://www.gnu.org/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Coreseek.com code.
*
* Copyright (C) 2007-2008. All Rights Reserved.
*
* Author:
*	Li monan <li.monan@gmail.com>
*
* ***** END LICENSE BLOCK ***** */

#ifndef _MM_THUNK_H_
#define _MM_THUNK_H_
#include <vector>
#include <math.h>
#include "UnigramDict.h"
#include "freelist.h"

#define CHUNK_BUFFER_SIZE 1024
#define CHUNK_DEBUG 0

namespace css {

class Chunk {
 public:
  Chunk() : m_free_score(0.0), total_length(0) {}
  float m_free_score;
  int total_length;
  std::vector<u2> tokens;
  std::vector<u2> freqs;
  inline void pushToken(u2 len, u2 freq) {
#if CHUNK_DEBUG
    printf("pt:%d, %d;\t", len, freq);
#endif
    tokens.push_back(len);
    total_length += len;
    freqs.push_back(freq);
    // m_free_score += log((float)freq) * 100;
  }
  inline float get_free() {
    // m_free_score
    float score = 0.0;
    std::vector<u2>::iterator it;
    float freq = 0;
    for (it = freqs.begin(); it < freqs.end(); it++) {
      freq = ((float)*it) + 1;
      score += log(freq) * 100;
    }
    return score;
  }
  inline float get_avl() {
    float avg = (float)1.0 * total_length / tokens.size();
    return avg;
  }
  inline float get_avg() {
    float avg = (float)1.0 * total_length / tokens.size();
    std::vector<u2>::iterator it;
    float total = 0;
    for (it = tokens.begin(); it < tokens.end(); it++) {
      float diff = ((*it) - avg);
      total += diff * diff;
    }
    return (float)1.0 * total / (tokens.size() - 1);
  }
  inline void popup() {
    if (tokens.size()) {
      total_length -= tokens[tokens.size() - 1];
      tokens.pop_back();
      freqs.pop_back();
    }
  }
  inline void reset() {
    tokens.clear();
    freqs.clear();
    total_length = 0;
  }
};

class ChunkQueue {
 public:
  ChunkQueue() : max_length(0){};

 public:
  void push(Chunk& ck) {
    if (ck.total_length < max_length) return;  // rule:1
    if (ck.total_length > max_length) {
      max_length = ck.total_length;
      m_chunks.clear();
    }
    m_chunks.push_back(ck);
  };
  u2 getToken() {
    size_t num_chunk = m_chunks.size();
    if (!num_chunk) return 0;
    if (num_chunk == 1) return m_chunks[0].tokens[0];
// debug use->dump chunk
#if CHUNK_DEBUG
    for (size_t i = 0; i < num_chunk; i++) {
      for (size_t j = 0; j < m_chunks[i].tokens.size(); j++)
        printf("%d,", m_chunks[i].tokens[j]);
      printf("\n");
    }
#endif
    // do filter
    // apply rule 2
    float avg_length = 0;
    u4 remains[256];  // m_chunks.size can not larger than 256;
    u4* k_ptr = remains;
    for (size_t i = 0; i < m_chunks.size(); i++) {
      float avl = m_chunks[i].get_avl();
      if (avl > avg_length) {
        avg_length = avl;
        k_ptr = remains;
        *k_ptr = (u4)i;
        k_ptr++;
      } else if (avl == avg_length) {
        *k_ptr = (u4)i;
        k_ptr++;
      }
    }
    if ((k_ptr - remains) == 1)
      return m_chunks[remains[0]].tokens[0];  // match by rule2
    // apply rule 3
    u4 remains_r3[256];
    u4* k_ptr_r3 = remains_r3;
    avg_length = 1024 * 64;  // an unreachable avg
    for (size_t i = 0; i < k_ptr - remains; i++) {
      float avg = m_chunks[remains[i]].get_avg();
      if (avg < avg_length) {
        avg_length = avg;
        k_ptr_r3 = remains_r3;
        *k_ptr_r3 = (u4)remains[i];  //*k_ptr_r3 = (u4)i;
        k_ptr_r3++;
      } else if (avg == avg_length) {
        *k_ptr_r3 = (u4)i;
        k_ptr_r3++;
      }
    }
    if ((k_ptr_r3 - remains_r3) == 1)
      return m_chunks[remains_r3[0]].tokens[0];  // match by rule3 min
                                                 // avg_length
    // apply r4 max freedom
    float max_score = 0.0;
    size_t idx = -1;
    for (size_t i = 0; i < k_ptr_r3 - remains_r3; i++) {
      float score = m_chunks[remains_r3[i]].get_free();
      if (score > max_score) {
        max_score = score;
        idx = remains_r3[i];
      }
    }
    return m_chunks[idx].tokens[0];
    // return 0;
  };
  inline void reset() {
    m_chunks.clear();
    max_length = 0;
  };

 protected:
  std::vector<Chunk> m_chunks;
  i4 max_length;
};

class item_info {
 public:
  item_info()
      :  // length(0),
        freq(0){};

 public:
  // u4 length;
  u4 freq;
  std::vector<u2> items;
};

class MMThunk {
 public:
  MMThunk() : base_offset(0), m_max_length(-1), m_length(0) {
    memset(m_charinfos, 0, sizeof(item_info*) * CHUNK_BUFFER_SIZE);
    memset(m_kwinfos, 0, sizeof(item_info*) * CHUNK_BUFFER_SIZE);
    item_list.set_size(CHUNK_BUFFER_SIZE * 2);
  };
  ~MMThunk(){};

  void setItems(i4 idx, u2 rs_count, UnigramDict::result_pair_type* results);
  void setKwItems(i4 idx, u2 rs_count, UnigramDict::result_pair_type* results);
  void advance(u2 step) { base_offset += step; };
  // peek the current token
  u1* peekToken(u2& length);
  u2 popupToken();
  u1* peekKwToken(u2& pos, u2& length);
  u2 popupKwToken();

  int Tokenize();
  void pushToken(u2 aSize, i4 base);
  void reset();
  u4 length() { return m_length; };

 protected:
  u2 base_offset;
  CRFPP::FreeList<item_info> item_list;
  item_info* m_charinfos[CHUNK_BUFFER_SIZE];
  std::vector<u2> tokens;
  item_info* m_kwinfos[CHUNK_BUFFER_SIZE];
  i4 m_kw_pos;
  i4 m_kw_ipos;
  i4 m_max_length;
  u4 m_length;
  ChunkQueue m_queue;

 protected:
  void pushChunk(Chunk& ck);
};
}

#endif