#pragma once
#include <string>
#include <sstream>
#include <iostream>
#include <ostream>

class Atomkern
{
    public:

    static const Atomkern PROTON;
    static const Atomkern NEUTRON;

    std::string _elementsymbol;
    int _ordnungszahl;
    int _massenzahl;

    

    Atomkern(std::string elementsymbol, int massenzahl, int ordnungszahl)
    {
        this->_elementsymbol = elementsymbol;
        this->_ordnungszahl = ordnungszahl;
        this->_massenzahl = massenzahl;
    }

     Atomkern(int massenzahl, int ordnungszahl)
    {
        this->_elementsymbol = " ";
        this->_ordnungszahl = ordnungszahl;
        this->_massenzahl = massenzahl;
    }


    Atomkern() // Standardatomkern: Wasserstoff
    {
        this->_elementsymbol = "H";
        this->_ordnungszahl = 1;
        this->_massenzahl = 1;
    }

    ~Atomkern() {}

    std::string symbol() const
    {
        return this->_elementsymbol;
    }

    int ordnungszahl() const
    {
        return this->_ordnungszahl;
    }

    int massenzahl() const
    {
        return this->_massenzahl;
    }

    Atomkern operator + (const Atomkern& atomkern_to_add) const
    {
        Atomkern ergebnis;

        ergebnis._ordnungszahl = this->_ordnungszahl + atomkern_to_add._ordnungszahl;
        ergebnis._massenzahl = this->_massenzahl + atomkern_to_add._massenzahl;

        return ergebnis;
    }

    void operator += (const Atomkern& atomkern_to_add)
    {
        this->_ordnungszahl += atomkern_to_add._ordnungszahl;
        this->_massenzahl += atomkern_to_add._massenzahl;
    }

    Atomkern operator - (const Atomkern& atomkern_to_subtract) const
    {
        Atomkern ergebnis;

        ergebnis._ordnungszahl = this->_ordnungszahl - atomkern_to_subtract._ordnungszahl;
        ergebnis._massenzahl = this->_massenzahl - atomkern_to_subtract._massenzahl;

        return ergebnis;
    }

    void operator -= (const Atomkern& atomkern_to_subtract)
    {
        this->_ordnungszahl -= atomkern_to_subtract._ordnungszahl;
        this->_massenzahl -= atomkern_to_subtract._massenzahl;
    }

    Atomkern operator * (const int factor) const
    {
        Atomkern ergebnis;

        ergebnis._ordnungszahl = this->_ordnungszahl * factor;
        ergebnis._massenzahl = this->_massenzahl * factor;
    
        return ergebnis;
    }


    int operator == (const Atomkern& atomkern_to_compare) const
    {
        if (this->_ordnungszahl == atomkern_to_compare._ordnungszahl && this->_massenzahl == atomkern_to_compare._massenzahl)
        {
            return 1;
        } 
        else
        {
            return 0;
        }
    }
};

std::ostream& operator<<(std::ostream& os, const Atomkern& atomkern);
Atomkern operator*(int factor, const Atomkern& atomkern);