#include <iostream>
#include <algorithm>

const int bitsPerOctet = 8;

struct BinaryOctet {
    bool evenParity;
    char bitsAsDigits[bitsPerOctet]{};
    BinaryOctet(int x = 0);
    BinaryOctet(const BinaryOctet&) = default;
    BinaryOctet &operator=(int &a);
    BinaryOctet operator--(int);
    BinaryOctet operator-(BinaryOctet &a);
    BinaryOctet operator+(BinaryOctet a);
    BinaryOctet operator/(BinaryOctet &a);
};

BinaryOctet::BinaryOctet(int x) {
    for (char &bitsAsDigit : bitsAsDigits) {
        bitsAsDigit = '0';
    }
    for (int i = 0; i <= bitsPerOctet - 1; i++) {
        int tmp = ((x >> i) & 1);
        bitsAsDigits[i] = (tmp == 1) ? '1' : '0';
    }
    //FIXME: das sollte eigentlich nicht benötigt werden
    std::reverse(std::begin(bitsAsDigits), std::end(bitsAsDigits));

    //einsen zählen
    int i = 0;
    for (char c : bitsAsDigits) {
        if (c == '1') i++;
    }

    evenParity = i % 2 == 0;
    //std::cout << evenParity << std::endl;
}

BinaryOctet &BinaryOctet::operator=(int &a) {
    std::string tmp = std::to_string(a);
    for (int i = 0; i >= tmp.length(); i++) {
        bitsAsDigits[i] = tmp[i];
    }
    return *this;
}

BinaryOctet BinaryOctet::operator--(int) {
    return operator-(*new BinaryOctet(1));
}

BinaryOctet BinaryOctet::operator-(BinaryOctet &a) {
    BinaryOctet result;
    bool over = false;
    for(int i = bitsPerOctet - 1; i >= 0; --i) {
        int tmp;
        int aI = a.bitsAsDigits[i] - '0';
        int bI = bitsAsDigits[i] - '0';

        if(over) tmp = bI - aI - 1;
        else tmp = bI - aI;
        over = false;

        if(tmp < 0) {
            over = true;
            tmp = tmp + 1;
        }
        result.bitsAsDigits[i] = static_cast<char>(tmp + '0');
    }
    return result;
}

BinaryOctet BinaryOctet::operator+(BinaryOctet a) {
    BinaryOctet result;
    bool over = false;
    for (int i = bitsPerOctet - 1; i >= 0; --i) {
        //Arbeitsvariablen anlegen und char in int umwandeln für einfachere Rechnung
        int tmp;
        int aI = a.bitsAsDigits[i] - '0';
        int bI = bitsAsDigits[i] - '0';


        if(over) tmp = aI + bI + 1;
        else tmp = aI + bI;
        over = false;


        if(tmp >= 2) {
            over = true;
            if (tmp % 2 == 0) tmp = 0;
            else tmp = 1;
        }

        //Umwandlung in char und ins Ergebnis schreiben
        result.bitsAsDigits[i] = static_cast<char>(tmp + '0');
    }
    return result;
}

BinaryOctet BinaryOctet::operator/(BinaryOctet &a) {
    BinaryOctet result;



    return result;
}

bool operator!=(BinaryOctet a, BinaryOctet b) {
    if (a.evenParity != b.evenParity) return false;
    for (int i = 0; i < bitsPerOctet; ++i) {
        if (a.bitsAsDigits[i] != b.bitsAsDigits[i]) return false;
    }
    return true;
}

BinaryOctet doCalculation(BinaryOctet a, BinaryOctet b) {
    BinaryOctet result;
    for (; a != b; b--) {
        a = a + 1;
        a = a / b;
    }
    result = a + b;
    return result;
}


// for println();
std::string as_string(BinaryOctet a) {
    std::string result = "(";
    for (char c : a.bitsAsDigits) {
        result += c;
    }
    result += ")";
    return result;
}


std::string as_string(BinaryOctet *a) {
    std::string result = "(";
    for (char c : a->bitsAsDigits) {
        result += c;
    }
    result += ")";
    return result;
}

// for std::cout
std::ostream &operator<<(std::ostream &os, const BinaryOctet &toBePrinted) {
    os << as_string(toBePrinted);
    return os;
}


std::ostream &operator<<(std::ostream &os, BinaryOctet *toBePrinted) {
    os << as_string(toBePrinted);
    return os;
}


int main(int argc, char **argv) {

    std::cout << "=========   init   ==========" << std::endl;
    BinaryOctet a = 0b00001111; //15
    std::cout << "a = " << a << std::endl;
    BinaryOctet b = 0b00000110;//6
    std::cout << "b = " << b << std::endl;
    auto *c = new BinaryOctet(5);
    std::cout << "c = " << c << std::endl;

    std::cout << "========   operator+   ===========" <<std::endl;
    std::cout << "a + b = " << a + b << std::endl;

    std::cout << "=========   operator-   ==========" << std::endl;
    std::cout << "a - b = " << a - b << std::endl;


    std::cout << "========   operator--   ============" << std::endl;
    BinaryOctet d = 0b111111111;
    d--;
    std::cout << d-- << std::endl;

    std::cout << "==============   doCalculation   ================" << std::endl;
    std::cout << "result = " << doCalculation(a, b) << std::endl;
    return 0;
}