#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stdlib.h>
 
using namespace std;
 
const int32_t JKF_TRAILER_SIZE = 60;
const int32_t JKF_PAGE_SIZE = 4096;
const int32_t JKF_CODEC_NONE = 2;
const int32_t JKF_CODEC_LZO = 0;
 
namespace jk_base {
    char DATABLOCKMAGIC[8] = {'D', 'A', 'T', 'A', 'B', 'L', 'K', 42};
    char INDEXBLOCKMAGIC[8] = {'I', 'D', 'X', 'B', 'L', 'K', 41, 43};
    char METABLOCKMAGIC[8] = {'M', 'E', 'T', 'A', 'B', 'L', 'K', 99};
    char TRAILERBLOCKMAGIC[8] = {'T', 'R', 'A', 'B', 'L', 'K', 34, 36};
    enum Mode {
        JKF_READ = 0,
        JKF_WRITE = 1,
    };
 
    // for debug
    void pgc(char c) {
        char a = (c>>4)&0x0f;
        char b = c&0x0f;
        if (a >= 10) a = 'a' + a - 10;
        else a = '0' + a;
        if (b >= 10) b = 'a' + b - 10;
        else b = '0' + b;
        cout << a << b << " ";
    }
    // end of debug
 
    class JKF_string {
        public:
            explicit JKF_string(const char * buf, int32_t length):str_(buf, length), poz_(0), length_(length) {};
            explicit JKF_string(const string & str) : str_(str), poz_(0), length_(str.size()) {};
            ~JKF_string() {};
            void read_int (int32_t * v) {
                char * pv = (char *)v;
                const char * buf = str_.c_str() + poz_; 
                poz_ += sizeof (int32_t);
                CHECK_LE (poz_, length_);
                pv[0] = buf[3];
                pv[1] = buf[2];
                pv[2] = buf[1];
                pv[3] = buf[0];
            };
 
            void read_int (int64_t * v) {
                char * pv = (char *)v;
                const char * buf = str_.c_str() + poz_; 
                poz_ += sizeof (int64_t);
                CHECK_LE (poz_, length_);
                pv[0] = buf[7];
                pv[1] = buf[6];
                pv[2] = buf[5];
                pv[3] = buf[4];
                pv[4] = buf[3];
                pv[5] = buf[2];
                pv[6] = buf[1];
                pv[7] = buf[0];
            };
 
            void read(char * buf, int32_t length) {
                const char * src = str_.c_str() + poz_;
                CHECK_LE (poz_ + length, length_);
                memcpy(buf, src, length);
                poz_ += length;
            };
 
            void read(string * value, int32_t length) {
                CHECK_LE (poz_ + length, length_);
                *value = string(str_, poz_, length);
                poz_ += length;
            };
 
            void seekg(int32_t length) {
                CHECK_LE (poz_ + length, length_);
                poz_ += length;
            };
 
            bool eof() { return poz_ >= length_;}
        private:
            string str_;
            int32_t poz_;
            int32_t length_;
    };
 
    class JKF_stream : public fstream {
        public:
            JKF_stream():fstream() {};
            explicit JKF_stream( const char * filename, ios_base::openmode mode = ios_base::in | ios_base::out ) : 
                fstream(filename, mode) {
                }
 
            ~JKF_stream(){};
 
            istream& read_int (int32_t * v) {
                fstream::read(buf_, sizeof (int32_t));
                char * pv = (char *)v;
                pv[0] = buf_[3];
                pv[1] = buf_[2];
                pv[2] = buf_[1];
                pv[3] = buf_[0];
                return *this;
            };
 
            istream& read_int (int64_t * v) {
                fstream::read(buf_, sizeof (int64_t));
                char * pv = (char *)v;
                pv[0] = buf_[7];
                pv[1] = buf_[6];
                pv[2] = buf_[5];
                pv[3] = buf_[4];
                pv[4] = buf_[3];
                pv[5] = buf_[2];
                pv[6] = buf_[1];
                pv[7] = buf_[0];
                return *this;
            };
 
            istream& read_vint (int32_t * v) {
                int32_t i = 0;
                int64_t sum = 0;
                do {
                    fstream::read(buf_ + i, 1);
                } while (buf_[i++] & 0x80);
 
                // TODO: (wangguangyuan) check the max size
                CHECK_LE(i, 5) << "vint exceed 5 bytes";
 
                while (i--) {
                    char t = buf_[i];
                    sum = (sum << 7) + (int64_t)t;
                }
                *v = sum;
                return *this;
            }
        private:
            char buf_[JKF_PAGE_SIZE];
    };
 
#pragma pack(1)
    struct JKF_trailer {
        char trailer_block_magic[8];
        int64_t file_info_offset;
        int64_t data_index_offset;
        int32_t data_index_count;
        int64_t meta_index_offset;
        int32_t meta_index_count;
        int64_t total_bytes;
        int32_t entry_count;
        int32_t compression_codec;
        int32_t version;
        // for debug
        void Print() {
            std::cout << "TrailerBlockMagic:";
            for (int32_t i = 0; i < 8; ++i) {
                printf("%c", trailer_block_magic[i]);
            }
            std::cout << endl;
            std::cout << "FileInfoOffset:" << file_info_offset << endl;
            std::cout << "DataIndexOffset:" << data_index_offset << endl;
            std::cout << "DataIndexCount:" << data_index_count << endl;
            std::cout << "MetaIndexOffset:" << meta_index_offset << endl;
            std::cout << "MetaIndexCount:" << meta_index_count << endl;
            std::cout << "TotalBytes:" << total_bytes << endl;
            std::cout << "EntryCount:" << entry_count << endl;
            std::cout << "CompressionCodec:" << compression_codec << endl;
            std::cout << "Version:" << version << endl;
        }
 
        bool Deserialize(JKF_stream & is) {
            is.read(trailer_block_magic, sizeof (trailer_block_magic));
            if (strncmp(trailer_block_magic, TRAILERBLOCKMAGIC, sizeof (trailer_block_magic)) != 0) {
                return false;
            }
            is.read_int(&file_info_offset);
            is.read_int(&data_index_offset);
            is.read_int(&data_index_count);
            is.read_int(&meta_index_offset);
            is.read_int(&meta_index_count);
            is.read_int(&total_bytes);
            is.read_int(&entry_count);
            is.read_int(&compression_codec);
            is.read_int(&version);
 
            Print();
            return true;
        }
    };
 
    struct JKF_data_index_block {
        int64_t block_begin;
        int32_t block_size;
        int32_t key_size; // note: vint
        std::string block_first_key; // the first key of the block
    };
#pragma pack()
 
    static bool DataIndexBlockCompare(const JKF_data_index_block & l, const JKF_data_index_block & r) {
        return (l.block_first_key < r.block_first_key);
    }
 
    class JKFile {
        public:
            JKFile();
            JKFile(const std::string & file_path, Mode mode);
            ~JKFile(){};
            bool Open(const std::string & file_path, Mode mode);
            bool Seek(const std::string & key, std::string * value);
            void Close();
            bool IsOpen() { return is_open_; };
 
        private:
            bool ReadTrailer();
            bool LoadDataIndex();
            bool SeekDataRecord(const JKF_data_index_block & block, const string & key, string * value);
            bool Decode(const char * buf, int32_t length, string * value);
            void ResizeBufferIfNeed(uint32_t hint) {
                if (hint > cur_buf_size_) {
                    VLOG(2) << "hint block size:" << hint;
                    delete(buf_);
                    cur_buf_size_ = 1;
                    int32_t i = 32;
                    for (; i > 0; --i) {
                        if (hint & 0x80000000) {
                            break;
                        }
                        hint = (hint<<1);
                    }
                    cur_buf_size_ = (cur_buf_size_<<i);
                    buf_ = (char *) malloc(cur_buf_size_);
                    VLOG(2) << "resize buffer:" << cur_buf_size_;
                }
            };
 
            JKF_stream ifs_;
            JKF_trailer trailer_;
            bool is_open_;
            vector<JKF_data_index_block> data_index_blocks_;
            int32_t header_offset_;
            util::Compression * compression_;  // 压缩解压工具
            char * buf_;
            uint32_t cur_buf_size_;
    };
 
    void JKFile::Close() {
        is_open_ = false;
        data_index_blocks_.clear();
        delete compression_;
        compression_ = NULL;
        free(buf_);
        buf_ = NULL;
        cur_buf_size_ = 0;
    }
 
    JKFile::JKFile() : is_open_(false), compression_(NULL), buf_(NULL), cur_buf_size_(0) {}
 
    JKFile::JKFile(const std::string & file_path, Mode mode) : is_open_(false),
                    compression_(NULL), buf_(NULL), cur_buf_size_(0) {
        Open(file_path, mode);
    }
 
    bool JKFile::LoadDataIndex() {
        // check index block magic
        char index_block_magic[8];
        ifs_.seekg(trailer_.data_index_offset, ios_base::beg);
        ifs_.read(index_block_magic, sizeof (index_block_magic));
        if (strncmp(index_block_magic, INDEXBLOCKMAGIC, sizeof (index_block_magic)) != 0) {
            VLOG(1) << "FATAL: data index block crash";
            return false;
        }
 
        // load data index blocks
        int32_t cur_buf_size = 32;
        char * buf = (char *)malloc(cur_buf_size * sizeof (char));
        CHECK(buf);
        for (int32_t i = 0; i < trailer_.data_index_count; ++i) {
            JKF_data_index_block block;
            ifs_.read_int(&block.block_begin);
            ifs_.read_int(&block.block_size);
            ifs_.read_vint(&block.key_size);
            // enlarge the buffer
            if (cur_buf_size <= block.key_size) {
                cur_buf_size = (cur_buf_size<<1) > block.key_size ? (cur_buf_size<<1) : (block.key_size + 1);
                free(buf);
                buf = NULL;
                buf = (char *)malloc(cur_buf_size * sizeof (char));
                CHECK(buf);
            }
            ifs_.read(buf, block.key_size);
            buf[block.key_size] = '\0';
            block.block_first_key = string(buf);
            data_index_blocks_.push_back(block);
 
            VLOG(6) << i << " block_info: begin[" << block.block_begin <<
                "] size[" << block.block_size << "] key_size[" << block.key_size << 
                "] block_first_key[" << block.block_first_key << "]";
        }
        free(buf);
        buf = NULL;
        return true;
    }
 
    bool JKFile::ReadTrailer() {
        ifs_.seekg(-JKF_TRAILER_SIZE, ios_base::end);
        return trailer_.Deserialize(ifs_);
    }
 
    bool JKFile::Open(const std::string & file_path, Mode mode) {
        if (mode == JKF_READ) {
            CHECK(!is_open_) << "JKFile already open, can't be re-opend";
            do {
                ifs_.open(file_path.c_str(), ios_base::in);
                if (!ifs_.is_open()) {
                    VLOG(1) << "FATAL: file not exist";
                    break;
                }
                if (!ReadTrailer()) {
                    VLOG(1) << "FATAL: read trailer fail";
                    break;
                }
                if (trailer_.compression_codec == JKF_CODEC_LZO) {
                    // 这里引用了成型的算法包
                    compression_ = util::Compression::GetCompressionAlgorithm("lzo");
                    if (NULL == compression_) {
                        VLOG(1) << "FATAL: get compr lzo fail";
                        break;
                    }
                }
                if (!LoadDataIndex()) {
                    VLOG(1) << "FATAL: load data index fail";
                    break;
                }
                is_open_ = true;
            } while (0);
            return true;
        } else {
            return false;
        }
    }
 
    bool JKFile::SeekDataRecord(const JKF_data_index_block & block, const string & key, string * value) {
        // prepare memory
        ResizeBufferIfNeed(block.block_size);
 
        // read the data block
        ifs_.seekg(block.block_begin, ios_base::beg);
        ifs_.read(buf_, block.block_size);
 
        // decode the data block
        string content;
        Decode(buf_, block.block_size, &content);
        JKF_string jkfs(content);
 
        // first compare the magic
        string magic;
        jkfs.read(&magic, 8);
        if (magic != string(DATABLOCKMAGIC, 8)) {    
            VLOG(1) << "WARNING: data block crash";
            return false;;
        }
 
        while (!jkfs.eof()) {
            int32_t key_length;
            int32_t value_length;
            string cur_key;
 
            jkfs.read_int(&key_length);
            jkfs.read_int(&value_length);
            jkfs.read(&cur_key, key_length);
            VLOG(6) << "key:" << cur_key;
 
            // find the key
            if (key == cur_key) {
                jkfs.read(value, value_length);
                return true;
            } else {
                // move the file pointer
                jkfs.seekg(value_length);
 
                // jkfs.read(value, value_length);
                // VLOG(6) << "value:" << *value << endl;
            }
        }
        return false;
    }
 
    bool JKFile::Decode(const char * buf, int32_t length, string * value) {
        if (trailer_.compression_codec == JKF_CODEC_NONE) {
            *value = string(buf, length);
            return true;
        } else if (trailer_.compression_codec == JKF_CODEC_LZO) {
            return compression_->Uncompress(buf, length, value);
        } else {
            return false;
        }
    }
 
 
    bool JKFile::Seek(const std::string & key, std::string * value) {
        // the JKFile must be opened
        CHECK(IsOpen());
 
        // binary search the lower bound of the key
        JKF_data_index_block catch_me;
        catch_me.block_first_key = key;
        vector<JKF_data_index_block>::iterator it;
        it = lower_bound(data_index_blocks_.begin(), data_index_blocks_.end(),
                   catch_me , DataIndexBlockCompare);
 
        // the check order must be right
        if (it != data_index_blocks_.end() && it->block_first_key == key) {
            VLOG(3) << "luckly hit the block's first key";
        } else if (it == data_index_blocks_.begin()) {
            VLOG(3) << "the key is the smallest, no proper block";
            return false;
        } else {
            VLOG(3) << "just try the pre block";
            --it;
        }
 
        // search in the maybe block
        return SeekDataRecord(*it, key, value);
    }
}
 
int main(int argc, char ** argv) {
    string file_name(argv[1]);
    jk_base::JKFile jkf(file_name, jk_base::JKF_READ);
    CHECK(jkf.IsOpen());
    string value, key;
    if (jkf.Seek(key, &value)) {
        cout << "value is:" << value << endl;
    } else {
        cout << "bad luck!" << endl;
    }
    return 0;
}
 
/* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */