#include <iostream>

#include "darray.h"
#include "dlist.h"

// #include "dstring.h"

#include <stdio.h>
#include <stdlib.h>
// #include <ctype.h>

#include "dstring.h"
#include "dstring.h"

#define CL_NIL      0
#define CL_ANY      1
#define CL_INT      2
#define CL_STRING   3
#define CL_REAL     4

using namespace std;

typedef double* Data;

int my_compare_f(Data &d1, Data &d2)
{
    // cout << "compare " << *d1 << "  --- " << *d2 << endl;
    if (*d1 == *d2)
        return 0;
    else if (*d1 > *d2)
        return 1;
    else
        return -1;
}

void my_delete_f(Data &d)
{
        if (d) delete d;
}

class A
{
public:
    A() : c('\0') {};

    A(char _c) : c(_c) {};

    char getChar() { return c; }


 private:
  char c;

};

typedef int (*FunctionPtr)(int);

struct _FunctionDeclr
{
    dstring     className;
    dstring     name;
    dstring     description;
    byte        *codePtr;
    u16         retClass;
    FunctionPtr func;

    void printFunction()
    {
        cout << "Class:" << className << " name:" << name << " (" << description << ") code=" << (!codePtr ? "NULL" : "") << " Ret class:" << retClass << endl;
    }
};

typedef struct _FunctionDeclr FunctionDeclr;

class ClassMeta
{
public:
    ClassMeta()
    {
        init();
    }

    virtual ~ClassMeta()
    {
       funcList.clear();
       superClassList.clear();

       cout << "ClassMeta: destructor" << endl;
    }

    virtual void setName(dstring _name)
    {
        name = _name;
    }

    virtual char *className()
    {
        return (char*)name.c_str();
    }

    static int compare_f(FunctionDeclr *&e1, FunctionDeclr *&e2)
    {
        return dstring::s_strcmp((char*)e1->name.c_str(), (char*)e2->name.c_str());
        // cout << "compare " << e1->name << " : " << e2->name << endl;
    }

    static void delete_f(FunctionDeclr *&e)
    {

    }

    int findFunction(char *_func)
    {
        int found;
        FunctionDeclr *f;
        FunctionDeclr fret;
        s32 idx;

        f = new FunctionDeclr();

        f->name = _func;
        fret.name = _func;

        // T &find_item(T &e, bool *found)
        idx = funcList.find_item(&fret, &found);

        if (!found)
        {
            // cout << "Fant IKKE " << f->name << endl;
            idx = -1;
        }

        return idx;
    }

    void addFunc(char *_name, char *_descr, byte *_codePtr, u16 _retClass, FunctionPtr _func)
    {
        int  idx;
        idx = findFunction(_name);

        // Function found in list
        if (idx > -1)
        {
            // Overload it
            funcList[idx]->className    = this->className();
            funcList[idx]->name         = _name;
            funcList[idx]->description  = _descr;
            funcList[idx]->codePtr      = _codePtr;
            funcList[idx]->retClass     = _retClass;
            funcList[idx]->func         = _func;
        }
        else {
            FunctionDeclr *f = new FunctionDeclr();
            f->className    = this->className();
            f->name         = _name;
            f->description  = _descr;
            f->codePtr      = _codePtr;
            f->retClass     = _retClass;
            f->func         = _func;

            funcList.add(f);
        }
    }

    virtual void listMemberFunctions()
    {
        u32 i;
        cout << this->className() << endl;

        for (i=0; i<funcList.size(); i++)
        {
            funcList[i]->printFunction();
        }
        cout << "-----" << endl;

        for (i=0; i<superClassList.size(); i++)
        {
            superClassList[i]->listMemberFunctions();
        }

        // ListItem<ClassMeta*> *item;
        //for (item=superClassList.begin(); item; item = item->next)
        // item->data->listMemberFunctions();
        // cout << "------------------------------------" << endl << endl;
    }


protected:
    DArray<FunctionDeclr*> funcList;
    DArray<ClassMeta*> superClassList;
    // DList<ClassMeta *> superClassList;

    dstring name;

private:
    virtual void init()
    {
        funcList.setSortFunction(ClassMeta::compare_f);
        funcList.setDeleteFunction(ClassMeta::delete_f);

        setName("MetaClass");
        cout << "ClassMeta init" << endl;
    }

};

// ------------------------------------------------

class ClassObject : public ClassMeta
{
public:
    ClassObject() : ClassMeta()
    {
        init();
    };

    virtual ~ClassObject()
    {
    };

private:

    void init()
    {
        // Commmon member functions to all classes
        addFunc("as_str", "Object as string",            0,  CL_STRING, &as_str);
        addFunc("class",  "Class name",                  0,  CL_STRING, &clsName);
        addFunc("null",  "Nullan",                       0,  CL_STRING, &nullan);

        setName("Object");

        cout << "ClassObject init" << endl;
    }


    static int as_str(int _set)
    {
        cout << "Object:as_str" << endl;
        return 0;
    }

    static int clsName(int _set)
    {
        cout << "Object:clsName" << endl;
        return 0;
    }

    static int nullan(int _set)
    {
        cout << "Object:nullan" << endl;
        return 0;
    }

};

// ----------------------------------------------------------------------

class ClassInteger : public ClassMeta
{
public:
    ClassInteger() : ClassMeta()
    {
        init();
    };

    virtual ~ClassInteger()
    {
        cout << "ClassInteger destructor" << endl;
    };

private:

    void init()
    {

        addFunc("+",     "Plus operator",            0,  CL_INT,     &plus);
        addFunc("-",     "Minus operator",           0,  CL_INT,     &minus);
        addFunc("*",     "Multiplication operator",  0,  CL_INT,     &mul);
        addFunc("/",     "Divison operator",         0,  CL_INT,     &div);
        addFunc("str",   "Int to string",            0,  CL_STRING,  &to_str);
        addFunc("float", "Int to float",             0,  CL_REAL,    &to_float);

        setName("Integer");

        // Add super class
        ClassMeta *cl = new ClassObject();

        superClassList.add(cl);

        cout << "ClassInteger init" << endl;
    }

    static int plus(int _set)
    {
    // a + b
        cout << "plus" << endl;
        return 0;
    }

    static int minus(int _set)
    {
    // a - b
        cout << "minus" << endl;
        return 0;
    }

    static int mul(int _set)
    {
    //  a * b
        cout << "mul" << endl;
        return 0;
    }

    static int div(int _set)
    {
    //  a / b
        cout << "div" << endl;
        return 0;
    }

    static int to_str(int _set)
    {
    //  a.str()
        cout << "to_str" << endl;
        return 0;
    }

    static int to_float(int _set)
    {
    //  a.float()
        cout << "to_float" << endl;
        return 0;
    }


};

class ClassUserDefined: public ClassMeta
{
public:
    ClassUserDefined(dstring _name) : ClassMeta()
    {
        setName(_name);
        init();
    };

    virtual ~ClassUserDefined()
    {
        cout << "ClassUserDefined destructor" << endl;
    };


    static int userFunction(int _set)
    {
    //  a.float()
        cout << "userFunction" << endl;
        return 0;
    }

private:
    dstring name;

    void init()
    {
        // Add super class
        ClassMeta *cl = new ClassObject();

        superClassList.add(cl);

        cout << "ClassUserDefined init" << endl;
    }



};


int main()
{
/*
    ModuleManager
    [0 1 2 3 4 5 6 ]
    std::Integer, std::String, std::Real, std::Complex, std:sys

    loadModule()
    installModule()

    findVariable()
    findClass()




*/
    // ClassObject  *clo = new ClassObject();

    // ClassInteger *cli = new ClassInteger();

    byte bb;
    ClassUserDefined *clu = new ClassUserDefined("MyClass");

    // addFunc(this->className(), "+",     "Plus operator",            0,  CL_INT,     &plus);
    clu->addFunc("myFunc1", "My Function 1", &bb , CL_ANY, &ClassUserDefined::userFunction);

    clu->listMemberFunctions();

    delete clu;

/*
    std::string st = "abcdef";
    st.erase(2);
    cout << st << endl;
    cout << "---------------------------" << endl;

    dstring st2 = "abcdef";
    st2.erase(12);
    cout << st2 << endl;
    cout << "---------------------------" << endl;

    std::string st3 = "abcdefg";
    st3.resize(4);
    cout << st3 << "/" << st3.length() << endl;

    dstring st4 = "abcdefg";
    st4.resize(4);
    cout << st4 << "/" << st4.length() << endl;

*/

    exit(0);

    cout << "sizeof(char)=" << sizeof(char) << endl;

   /* dstring s("hello 2");

    cout << s.length() << ":" << s << endl;

    cout << s.c_str() << endl;

    cout << "------------------------------" << endl;

    dstring s2('A', 21);
	dstring s3('B');

    cout << s2 << ":" << s2.length() << endl;
    cout << s3 << ":" << s3.length() << endl;
    cout << "------------------------------" << endl;

    dstring s4(-19);
    dstring s5((unsigned int) 76151);
    cout << s4 << ":" << s4.length() << endl;
    cout << s5 << ":" << s5.length() << endl;
    cout << "------------------------------" << endl;

    dstring s6(s2);
    cout << s6 << ":" << s6.length() << endl;
    cout << "------------------------------" << endl;

    dstring s7 = "This a string.1234567890";
    dstring s8 = s4;
    cout << s7 << ":" << s7.length() << endl;
    cout << s8 << ":" << s8.length() << endl;
    cout << "------------------------------" << endl;
*/

    dstring s9("a");
    dstring s10 = s9 + 'c' + "abc";

    cout << s9 << ":" << s9.length() << endl;
    cout << s10 << ":" << s10.length() << endl;
    cout << "------------------------------" << endl;


    dstring s11="abcdd";
    dstring s12="abcd";


    if (s11 == s12)
        cout << "s11 == s12" << endl;

    if (s11 != s12)
        cout << "s11 != s12" << endl;

    if (s11 < s12)
        cout << "s11 < s12" << endl;

    if (s11 <= s12)
        cout << "s11 <= s12" << endl;

    if (s11 > s12)
        cout << "s11 > s12" << endl;

    if (s11 >= s12)
        cout << "s11 >= s12" << endl;



    u32 i;
    for (i=0; i<10; i++)
        cout << i << ":" << s12[i] << endl;

    cout << "------------------------------" << endl;

    // cin >> s11;
    // cout << "s11=" << s11 << endl;


    /*
        DArray<double> arr;
        double d;
        int i;

        DArray<A> arrA;
        DArray<int*> arri;

        for (i=0; i<10; i++)
        {
        d = i *10.00;
        arr += d;
        }

        for (i=0; i<arr.size(); i++)
        {
        cout << i << ": " << arr[i] << endl;
        }
*/

    //String s;
    //String s2 = "hello"


/*
     int i = 9;
     char buffer[128];


    i = strcasecmp("hjjhj", "hhjjhjk");
    // i = _stricmp("hghggh", "jhjhjh");



    DList<double*> li(my_compare_f, my_delete_f);
    int i;
    // Data item;
    ListItem<double*> *item;
    Data data;
    long dd;

    for (i=0; i<10; i++)
    {
        dd = (rand() % 1000) * 1;
        data = new double(dd);
        li.push_back(data);
    }

    data = new double(33333.33);
    li.push_front(data);

    for (item = li.head(); item; item = item->next)
    {
        cout << "Item:" << *item->data << endl;
    }

    cout << "------------- " << li.length() << " ----------------" << endl;

    for (item = li.tail(); item; item = item->prev)
    {
        cout << "Item:" << *item->data << endl;
    }

    cout << "------------- " << li.length() << " ----------------" << endl;

    cout << "at(3)=" << *li.at(3) << endl;
    cout << "at(5)=" << *li.at(5) << endl;


    li.clear();

    cout << "------------- " << li.length() << " ----------------" << endl;

    DList<A> alist;
    DArray<A> aarray;

    for (i=0; i<10; i++)
    {
        A *aa = new A(i+65);
        alist += *aa;
    }

    // while (alist.size())
    alist.delete_last();

    for (i=0; i<alist.size(); i++)
    {
        A k = alist[i];
        cout << ": " << k.getChar() << endl;
    }

    std::cout << "Hello world!" << std::endl;
*/

    return 0;

}