/*
        main.cpp
    */
    #include "utils.h"
    #include <iostream>
    #include <string>
    using std::cin;
    using std::cout;
    using std::endl;
    using std::string;
    int main(int argc, char** argv)
    {
        try
        {
            BigInt* pright = new BigInt;
            pright->data = 9;
            pright->next = new BigInt;
            pright->next->data = 9;
            pright->next->next = new BigInt;
            pright->next->next->data = 9;
            cout << "right is: " << *pright << endl;
            BigInt* pleft = new BigInt;
            pleft->data = 9;
            pleft->next = new BigInt;
            pleft->next->data = 9;
            pleft->next->next = new BigInt;
            pleft->next->next->data = 9;
            cout << "left is: " << *pleft << endl;
            BigInt* res = (*pleft) * (*pright);
            cout << "the result is: " << *res << endl;
            BigInt abc;
            cout << "pleas input the left num: ";
            cin >> abc;
            BigInt def;
            cout << "pleas input the right num: ";
            cin >> def;
            res = abc * def;
            cout << "the result is: " << *res << endl;
        }
        catch (string e)
        {
            cout << e;
            return -1;
        }
        return 0;
    }
    

    /*
        utils.h
    */
    #ifndef __UTILS_MY__
    #define __UTILS_MY__
    #include <iostream>
    #include "bigint.h"
    using std::istream;
    using std::ostream;
    BigInt* operator* (BigInt& plhs, BigInt& prhs);
    istream& operator>> (istream& in, BigInt& n);
    ostream& operator<< (ostream& out, BigInt& n);
    #endif
    /*
        utils.cpp
    */
    #include <string>
    #include "utils.h"
    using std::string;
    using std::cout;
    /*
    *    d 的取值范围 [0, 9]
    */
    BigInt* Addonenum (BigInt* pnum, unsigned char d)
    {
        if (d > 9 || d == 0)
        {
            return pnum;
        }
        if (!pnum)
        {
            pnum = new BigInt;
            pnum->data = d;
            return pnum;
        }
        d += pnum->data;
        if (d > 9)
        {
            pnum->next = Addonenum(pnum->next, d / 10);
        }
        pnum->data = d % 10;
        return pnum;
    }
    BigInt* operator* (BigInt& plhs, BigInt& prhs)
    {
        BigInt* preshead = new BigInt;
        if (plhs.iszero() || prhs.iszero())
        {
            return preshead;
        }
        if ((plhs.isneg() && !prhs.isneg()) || (!plhs.isneg() && prhs.isneg()))
        {
            preshead->bneg = true;
        }
        BigInt* presnumpos1 = preshead;
        BigInt* presnumpos2 = preshead;
        BigInt* plhsnum = &plhs;
        unsigned char d = 0;
        while (plhsnum)
        {
            presnumpos1 = presnumpos2;
            BigInt* prhsnum = &prhs;
            while (prhsnum)
            {
                d = prhsnum->data * plhsnum->data;
                presnumpos1 = Addonenum(presnumpos1, d % 10);
                presnumpos1->next = Addonenum(presnumpos1->next, d / 10);
                presnumpos1 = presnumpos1->next;
                prhsnum = prhsnum->next;
            }
            plhsnum = plhsnum->next;
            presnumpos2 = presnumpos2->next;
        }
        return preshead;
    }
    istream& operator>> (istream& in, BigInt& n)
    {
        BigInt* pn = &n;
        BigInt* prenode = pn;
        string src;
        in >> src;
        string::reverse_iterator itrbegin = src.rbegin();
        string::reverse_iterator itrend = src.rend();
        if (src.at(0) == '-')
        {
            n.bneg = true;
            itrend--;
        }
        else if (src.at(0) == '+')
        {
            itrend--;
        }
        for (string::reverse_iterator it = itrbegin; it != itrend; it++)
        {
            if (*it > '9' || *it < '0')
            {
                throw "input num error: " + src + "!";
            }
            if (!pn)
            {
                // new node;
                pn = prenode->next = new BigInt;
                prenode = pn;
            }
            pn->data = *it - '0';
            pn = pn->next;
        }
        return in;
    }
    ostream& operator<< (ostream& out, BigInt& n)
    {
        BigInt* pn = &n;
        string outstr;
        BigInt* prev = NULL;
        BigInt* pout = NULL;
        while (pn)
        {
            pout = new BigInt;
            pout->data = pn->data;
            if (prev)
            {
                pout->next = prev;
            }
            prev = pout;
            pn = pn->next;
        }
        if (n.isneg())
        {
            outstr += '-';
        }
        while (pout)
        {
            outstr += (char)(pout->data + '0');
            pout = pout->next;
        }
        return out << outstr;
    }
    

/*
        bitint.h
    */
    #ifndef __BIGINT__
    #define __BIGINT__
    struct BigInt 
    {
    public:
        unsigned char data;
        BigInt* next;
        bool bneg;
        BigInt()
        {
            next = NULL;
            bneg = false;
            data = 0;
        }
        ~BigInt()
        {
            if (next)
            {
                delete next;
                next = NULL;
            }
        }
        bool iszero()
        {
            BigInt* pn = this;
            while (pn && pn->data != 0)
            {
                return false;
                pn = pn->next;
            }
            return true;
        }
        bool isneg()
        {
            if (iszero())
            {
                return false;
            }
            return bneg;
        }
    };
    #endif