#pragma execution_character_set("utf-8")
#include<windows.h> 
#include <iostream>
#include <fstream>
#include<vector>  
#include"define.h"
#include"cinterface.h"
struct mecab_node_t {
    struct mecab_node_t* prev;
    struct mecab_node_t* next;
    struct mecab_node_t* enext;
    struct mecab_node_t* bnext;
    struct mecab_path_t* rpath;
    struct mecab_path_t* lpath;
    const char* surface;
    const char* feature;
    unsigned int          id;
    unsigned short        length;
    unsigned short        rlength;
    unsigned short        rcAttr;
    unsigned short        lcAttr;
    unsigned short        posid;
    unsigned char         char_type;
    unsigned char         stat;
    unsigned char         isbest;
    float                 alpha;
    float                 beta;
    float                 prob;
    short                 wcost;
    long                  cost;
};

typedef struct mecab_t                 mecab_t;
typedef mecab_t* (*mecab_new)(int argc, char** argv);
typedef mecab_node_t* (*mecab_sparse_tonode)(mecab_t* mecab, const char*); 
typedef void (*mecab_destroy)(mecab_t* mecab);
HMODULE mecablib;
void* mecab_init(char* utf8path,wchar_t*mepath) { 
    mecablib = LoadLibraryW(mepath);
    if (mecablib == 0)return 0;
    auto _mecab_new = (mecab_new)GetProcAddress(mecablib, "mecab_new"); 
    if (_mecab_new == 0)return 0;
    std::vector<std::string> vargv = { "fugashi","-C","-r","nul","-d",utf8path,"-Owakati" };
    
    auto argv = vecstr2c(vargv);
    auto trigger = _mecab_new(vargv.size(), argv);
    freestringlist(argv, vargv.size());
    return trigger;
}
void mecab_end(void*trigger){
    if (trigger == 0)return  ;
    if (mecablib == 0)return  ;
    auto _mecab_destroy = (mecab_destroy)GetProcAddress(mecablib, "mecab_destroy");
    if (_mecab_destroy == 0)return  ;
    mecab_destroy((mecab_t*)trigger);
}
bool mecab_parse(void* trigger,char*utf8string, char*** surface, char*** features,int*num) {
    if (trigger == 0)return false;
    if (mecablib == 0)return false;
    auto _mecab_sparse_tonode = (mecab_sparse_tonode)GetProcAddress(mecablib, "mecab_sparse_tonode");
    if (_mecab_sparse_tonode == 0)return false;

    std::string cstr = utf8string;
    auto node = _mecab_sparse_tonode((mecab_t*)trigger, cstr.c_str());

    std::vector<std::string>surfs;
    std::vector<std::string>featuresv;
    while (node->next) {
        node = node->next;
        if (node->stat == 3) {
            break;
        }
        std::string surf = node->surface;
        surf = surf.substr(0, node->length);
        surfs.emplace_back( surf);
        featuresv.emplace_back(node->feature);
    }
    *surface = vecstr2c(surfs);
    *features = vecstr2c(featuresv);
    *num = surfs.size();
    return true;
}