#ifndef _DAWG_GRAPHIC_H
#define _DAWG_GRAPHIC_H
#define ALPHABET_SIZE 256
#define MAX_STATE 100
#define PATTERN_LEN 50
#include <map>
#include<iostream>
using namespace std;

struct CDawg_node
{
    short node_order;
    short next[ALPHABET_SIZE];
    map<char,char> edge_type;  
    CDawg_node* suffix_node;
    CDawg_node(short order)
    {
        node_order = order;
        memset(next, 0, ALPHABET_SIZE*sizeof(short));
        suffix_node = 0;
    }
    void set_next_state(char accept_char, int next_state, char is_primary)
    {
        next[accept_char] = next_state;
        edge_type[accept_char] = is_primary;
    }
};

class CDawg
{
private:
    CDawg_node* source;
    CDawg_node* state_set[MAX_STATE];
    short assign_state;
public:
    CDawg(char* pats)
    {
        assign_state = 0;
        source = new CDawg_node(assign_state ++);
        state_set[0] = source;
        __setup_dawg(pats);
    }
    void print_dawg();
    bool is_over_state(short state)
    {
        CDawg_node* __temp_dawg_node = state_set[state];
        return __temp_dawg_node->edge_type.size() == 0;
    }

short get_next_state(short state, char accpet_char)
    {
        CDawg_node* _temp_dawg_node = state_set[state];
        short  next_state = _temp_dawg_node->next[accpet_char];
        if( next_state == 0)
        {
            return -1;
        }
        return next_state;
    }

private:
    void __setup_dawg(char* pats);
    CDawg_node* __update_dawg(CDawg_node* active_node, char accept_char);
    CDawg_node* __split_node(CDawg_node* parent, CDawg_node* child, char accept_char);
};
#endif

#include "daw_graphic.h"

void CDawg::__setup_dawg(char* pats)
{
    CDawg_node* active_node = source;
    int len = strlen(pats);
    for(int i = 0; i < len; i ++)
    {
        if(pats[i] == ' ')
        {
            active_node = source;
        }
        else
        {
            active_node = __update_dawg(active_node, pats[i]);
        }
    }
}

CDawg_node* CDawg::__update_dawg(CDawg_node* active_node, char accept_char)
{
    short next_state = active_node->next[accept_char];
    CDawg_node* new_active_node;
    if(next_state != 0)
    {
        new_active_node = state_set[next_state];
        if(active_node->edge_type[accept_char] == 2)
        {
            return new_active_node;
        }
        else
        {
            return __split_node(active_node, new_active_node, accept_char);
        }
    }
    else
    {
        CDawg_node* cur_node = active_node;
        CDawg_node* suffix_node = 0;
        CDawg_node* child_node = 0;
        active_node->set_next_state(accept_char, assign_state, 2);
        new_active_node = new CDawg_node(assign_state);
        state_set[assign_state ++] = new_active_node;
        
        while(cur_node != source && suffix_node == 0)
        {
            cur_node = cur_node->suffix_node;//TODO
            
            if(cur_node->edge_type.find(accept_char) != cur_node->edge_type.end() 
                && cur_node->edge_type[accept_char] == 2)
            {
                suffix_node = state_set[cur_node->next[accept_char]];
            }

else if(cur_node->edge_type.find(accept_char) != cur_node->edge_type.end()
                && cur_node->edge_type[accept_char] == 1)
            {
                child_node = state_set[cur_node->next[accept_char]];
                suffix_node = __split_node(cur_node, child_node, accept_char);
            }
            else
            {
                cur_node->set_next_state(accept_char, new_active_node->node_order, 1);
            }
        }

if(suffix_node == 0)
        {
            suffix_node = source;
        }
        new_active_node->suffix_node = suffix_node;
        return new_active_node;
    }
}

CDawg_node* CDawg::__split_node(CDawg_node* parent, CDawg_node* child, char accept_char)
{
    CDawg_node* new_dawg_node = new CDawg_node(assign_state);
    parent->set_next_state(accept_char, assign_state, 2);
    
    state_set[assign_state ++] = new_dawg_node;
    
    typedef map<char,char>::iterator CB;
    for(CB p = child->edge_type.begin(); p != child->edge_type.end(); p ++)
    {
        char key = p->first;
        short state = child->next[key];
        new_dawg_node->set_next_state(key, state, 1);
    }
    
    new_dawg_node->suffix_node = child->suffix_node;
    child->suffix_node = new_dawg_node;
    CDawg_node* cur_node = parent;

while (cur_node != source)
    {
        cur_node = cur_node->suffix_node;
        short __find_state = child->node_order;
        bool is_ret = false;
        
        
        for(CB q = cur_node->edge_type.begin(); q != cur_node->edge_type.end(); q ++)
        {
            char state_char = q->first;
            if(cur_node->next[state_char] == __find_state && ( q->second) == 1)
            {
                cur_node->set_next_state(state_char, new_dawg_node->node_order, 1);
                is_ret = true;
                break;
            }
        }
        if(is_ret)
        {
            break;
        }
    }
    return new_dawg_node;
}

void CDawg::print_dawg()
{
    for(int i = 0; i < assign_state; i ++)
    {
        CDawg_node* _temp_dawg_node = state_set[i];
        for(int j = 0; j < ALPHABET_SIZE; j ++)
        {
            if(_temp_dawg_node->next[j] != 0)
            {
                cout<<i<<"--"<<(char)j<<"-->"<<_temp_dawg_node->next[j]<<endl;
            }
        }
        cout<<endl;
    }
}