extern "C" {
#include "sc_memory_headers.h"
#include "sc_helper.h"
#include "utils.h"
}

#include <stdio.h>
#include <iostream>
#include <glib.h>
#include <unistd.h>
#include <assert.h>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

sc_memory_context *context;

sc_addr graph, rrel_arcs, rrel_nodes, visit, curr_vertex, father;

sc_bool set_is_not_empty(sc_addr set)
{
    sc_iterator3 *check = sc_iterator3_f_a_a_new(context,
                                                 set,
                                                 sc_type_arc_pos_const_perm,
                                                 0);
    if (SC_TRUE == sc_iterator3_next(check)) {
        return SC_TRUE;
    } else {

        return SC_FALSE;
    }
}

sc_bool find_vertex_in_set(sc_addr element, sc_addr set)
{
    sc_bool find = SC_FALSE;

    sc_iterator3 *location = sc_iterator3_f_a_a_new(context,
                                                    set,
                                                    sc_type_arc_pos_const_perm,
                                                    0);

    while (SC_TRUE == sc_iterator3_next(location)) {
        sc_addr loc = sc_iterator3_value(location, 2);

        if (SC_ADDR_IS_NOT_EQUAL(loc, element)) {
            find = SC_FALSE;
            continue;
        } else {
            find = SC_TRUE;
            break;
        }
    }
    return find;
}

void get_edge_vertexes(sc_addr edge, sc_addr &v1, sc_addr &v2)
{
    sc_memory_get_arc_begin(context, edge, &v1);
    sc_memory_get_arc_end(context, edge, &v2);
}

void print_graph()
{
    sc_addr arcs, nodes, loc, v1, v2, printed_vertex;
    sc_bool find;
    printed_vertex = sc_memory_node_new(context, sc_type_const);

    printEl(context, graph);
    cout << endl << "----------------------" << endl;

    sc_iterator5 *it = sc_iterator5_f_a_a_a_f_new(context,
                                                  graph,
                                                  sc_type_arc_pos_const_perm,
                                                  0,
                                                  sc_type_arc_pos_const_perm,
                                                  rrel_arcs);

    if (SC_TRUE == sc_iterator5_next(it)) {
        arcs = sc_iterator5_value(it, 2);

        sc_iterator3 *arcs_it = sc_iterator3_f_a_a_new(context,
                                                       arcs,
                                                       sc_type_arc_pos_const_perm,
                                                       0);

        while (SC_TRUE == sc_iterator3_next(arcs_it)) {

            sc_addr t_arc = sc_iterator3_value(arcs_it, 2);

            get_edge_vertexes(t_arc, v1, v2);

            printEl(context, v1);
            printf(" — ");
            printEl(context, v2);
            cout << endl;

            if (SC_FALSE == find_vertex_in_set(v1, printed_vertex))
                sc_memory_arc_new(context, sc_type_arc_pos_const_perm, printed_vertex, v1);
            if (SC_FALSE == find_vertex_in_set(v2, printed_vertex))
                sc_memory_arc_new(context, sc_type_arc_pos_const_perm, printed_vertex, v2);
        }
        sc_iterator3_free(arcs_it);
    }

    sc_iterator5_free(it);

    it = sc_iterator5_f_a_a_a_f_new(context,
                                    graph,
                                    sc_type_arc_pos_const_perm,
                                    0,
                                    sc_type_arc_pos_const_perm,
                                    rrel_nodes);

    if (SC_TRUE == sc_iterator5_next(it)) {
        nodes = sc_iterator5_value(it, 2);

        sc_iterator3 *nodes_it = sc_iterator3_f_a_a_new(context,
                                                        nodes,
                                                        sc_type_arc_pos_const_perm,
                                                        0);

        while (SC_TRUE == sc_iterator3_next(nodes_it)) {

            sc_addr t_node = sc_iterator3_value(nodes_it, 2);

            find = find_vertex_in_set(t_node, printed_vertex);

            if (find == SC_FALSE) {
                printEl(context, t_node);
                cout << endl;
            }
        }
        sc_iterator3_free(nodes_it);
    }
    sc_iterator5_free(it);
}

bool dfs(sc_addr vertex, bool side, sc_addr arcs, sc_addr green, sc_addr red) {
    if (side)
        sc_memory_arc_new(context, sc_type_arc_pos_const_perm, green, vertex);
    else
        sc_memory_arc_new(context, sc_type_arc_pos_const_perm, red, vertex);


    sc_iterator5* it_vertex = sc_iterator5_f_a_a_a_f_new(context,
                                                         vertex,
                                                         sc_type_arc_common,
                                                         0,
                                                         sc_type_arc_pos_const_perm,
                                                         arcs);

    while (SC_TRUE == sc_iterator5_next(it_vertex)) {
        sc_addr adjacent = sc_iterator5_value(it_vertex, 2);

        bool isRed = sc_helper_check_arc(context, red, adjacent, sc_type_arc_pos_const_perm);
        bool isGreen = sc_helper_check_arc(context, green, adjacent, sc_type_arc_pos_const_perm);

        if (!isRed && !isGreen) {
            bool res = dfs(adjacent, !side, arcs, green, red);

            if (res) return res;
        } else if ((isRed && !side) || (isGreen && side)) {
            return true;
        }
    }

    sc_iterator5_free(it_vertex);

    return false;
}

bool isGraphBipartite(sc_addr beg_vertex)
{
    sc_addr green = sc_memory_node_new(context, sc_type_const);
    sc_addr red = sc_memory_node_new(context, sc_type_const);

    sc_iterator5 *arcs = sc_iterator5_f_a_a_a_f_new(context,
                                                    graph,
                                                    sc_type_arc_pos_const_perm,
                                                    0,
                                                    sc_type_arc_pos_const_perm,
                                                    rrel_arcs);

    sc_iterator5_next(arcs);

    sc_addr allArcs = sc_iterator5_value(arcs, 2);

    sc_iterator5_free(arcs);

    bool result = !dfs(beg_vertex, false, allArcs, green, red);



    return result;
}

void run_test(char number_test, sc_char *beg_vertex)
{
    sc_addr beg;
    father = sc_memory_node_new(context, sc_type_const);

    char gr[3] = "Gx";
    gr[1] = number_test;
    sc_helper_resolve_system_identifier(context, gr, &graph);
    sc_helper_resolve_system_identifier(context, "rrel_arcs", &rrel_arcs);
    sc_helper_resolve_system_identifier(context, "rrel_nodes", &rrel_nodes);
    sc_helper_resolve_system_identifier(context, beg_vertex, &beg);

    cout << "Graph: ";

    //print_graph();

    cout <<"Check graph"<<endl;
    bool isBipartite = isGraphBipartite(beg);

    if (isBipartite) {
        cout<<"Graph is bipartite";
    } else {
        cout << "Graph is not bipartite " << endl;
    }

    cout << endl;
    sc_memory_element_free(context, father);
}

int main()
{
    sc_memory_params params;

    sc_memory_params_clear(&params);
    params.repo_path = "/home/wcobalt/Files/BSUIR/ostis/kb.bin";
    params.config_file = "/home/wcobalt/Files/BSUIR/ostis/config/sc-web.ini";
    params.ext_path = "/home/wcobalt/Files/BSUIR/ostis/sc-machine/bin/extensions";
    params.clear = SC_FALSE;

    sc_memory_initialize(&params);

    context = sc_memory_context_new(sc_access_lvl_make_max);

//////////////////////////////////////////////////////////////////////////////////
    run_test('2', (sc_char *)"V1");
/*    run_test('1', (sc_char *)"V1");
    run_test('2', (sc_char *)"V1");
    run_test('3', (sc_char *)"V1");
    run_test('4', (sc_char *)"V5");*/
    cout << "The end" << endl;

    sc_memory_context_free(context);

    sc_memory_shutdown(SC_TRUE);

    return 0;
}