#include <iostream>
#include <map>
#include <vector>
#include <deque>
#include <algorithm>
#include <bitset>
#include <math.h>
#include <string>
#include <set>
#include <fstream>
#include <valarray>
#include <iomanip>
#include <bitset>
#include <random>
#include <complex>
#include <random>
#include <unordered_map>
#include <unordered_set>
using namespace std;
class apple {
    // пищевая ценность продукта
protected: int value;
private:

    string color , type , country ;
    vector<string> clrs = {"red" , "blue" , "green" , "yellow" , "white" , "golden"};
    vector<string> ctrs = {"Russia" , "Ecuador" , "Columbia" , "Argentina" , "Brazil" , "Netherlands"};
    vector<string> tps = {"beutifull apple" , "apple" , "big apple" , "small apple" , "tasty apple" , "pineapple"};
    int weight , Fe , kcal , vitB , vitA , vitC , Mg ;
    // поменять содержание витаминов А и В
    void swap_A_B() { swap(vitA , vitB); }
    // поменять содержание железа и магния
    void swap_Fe_Mg(){ swap(Fe , Mg); }
    // перемешать порядок стран
    void shuffle_ctrs() {
        random_shuffle(ctrs.begin(), ctrs.end());
    }
    // перемешать порядок цветов
    void shuffle_clrs() {
        random_shuffle(clrs.begin(), clrs.end());
    }
    // перемешать порядок типов
    void shuffle_tps() {
        random_shuffle(tps.begin(), tps.begin());
    }
    // добавить еще одну страну происхождения
    void add_to_ctrs(string cnt) {
        ctrs.push_back(cnt);
    }
    // добавить еще один возможный цвет
    void add_to_clrs(string cnt) {
        clrs.push_back(cnt);
    }
    // добавить еще возможный тип
    void add_to_tps(string cnt) {
        tps.push_back(cnt);
    }
public:
    void hello() { cout << "Объект класса яблоко\n"; }
    // конструктор по умлочанию
    apple() {
        cout << "сработал конструктор по умолчанию, данных нет\n";
    }
    // конструктор для всех начальных данных
    apple(string color , string type , string country , int weight ,int kcal , int Fe , int Mg , int vitA , int vitB , int vitC ) {
        cout << "сработал конструктор, установленны данные\n";
        set_apple(color, type , country , weight , kcal , Fe , Mg , vitA , vitB , vitC);
    }
    // конструктор для начальных данных цвет и тип, если вы только видете это яблоко
    apple(string color , string type ) {
        cout << "сработал конструктор с двумя изначальными параметрами, установленны данные\n";
        set_color(color);
        set_type(type);
    }
    // конструктор для начальных данных цвет
    apple(string color) {
        cout << "сработал конструктор, если известен только цвет\n";
        set_color(color);
    }
    // устанавливаем private параметрам новые данные
    friend const apple operator*(const apple& left, const apple& right);
    friend const apple operator+(const apple& left, const apple& right);
    friend ostream& operator<<(ostream& os, const apple& app);
    //  все страны которые есть в базе
    void get_ctrs() {
        cout << "текущий список возможных стран: \n";
        for(int i = 0; i < ctrs.size(); i++) {
            cout << ctrs[i] << " ";
        }
        cout << "\n";
    }
    //  все цвета которые есть в базе
    void get_clrs() {
        cout << "текущий список возможных цветов: \n";
        for(int i = 0; i < clrs.size(); i++) {
            cout << clrs[i] << " ";
        }
        cout << "\n";
    }
    //  все типы которые есть в базе
    void get_tps() {
        cout << "текущий список возможных типов: \n";
        for(int i = 0; i < tps.size(); i++) {
            cout << tps[i] << " ";
        }
        cout << "\n";
    }
    // дополнение словаря стран + использование приватного метода
    void to_ctrs(vector<string> &to_add) {
        for(int i = 0; i < to_add.size(); i++) {
            add_to_ctrs(to_add[i]);
        }
    }
    // дополнение словаря цветов + использование приватного метода
    void to_clrs(vector<string> &to_add) {
        for(int i = 0; i < to_add.size(); i++) {
            add_to_clrs(to_add[i]);
        }
    }
    // дополнение словаря типов + использование приватного метода
    void to_tps(vector<string> &to_add) {
        for(int i = 0; i < to_add.size(); i++) {
            add_to_tps(to_add[i]);
        }
    }
    // очистить словарь стран
    void clear_countries() { ctrs.clear(); }
    // очистить словарь цветов
    void clear_colors() { clrs.clear(); }
    // очистить словарь типов
    void clear_types() { tps.clear(); }
    // передать и заменить новый словарь стран
    void new_countries(vector<string> &to_add) {
        clear_countries();
        to_ctrs(to_add);
    }
    // передать и заменить новый словарь стран
    void new_colors(vector<string> &to_add) {
        clear_colors();
        to_clrs(to_add);
    }
    // передать и заменить новый словарь типов
    void new_types(vector<string> &to_add) {
        clear_types();
        to_tps(to_add);
    }
    // установка яблока со всеми параметрами
    void set_apple(string new_color , string new_type , string new_country , int new_weight ,int new_kcal , int new_Fe , int new_Mg , int new_vitA , int new_vitB , int new_vitC ) {
        cout << "все свойства установлены \n";
        color = new_color;
        type = new_type;
        country = new_country;
        weight = new_weight;
        kcal = new_kcal;
        Fe = new_Fe;
        Mg = new_Mg;
        vitA = new_vitA;
        vitB = new_vitB;
        vitC = new_vitC;
    }
    // делаем случайное яблоко
    void set_rand_apple() {
        cout << "случайная инициализация: ";
        int num_con = rand() % ctrs.size();
        int num_col = rand() % clrs.size();
        int num_type = rand() % tps.size();
        string clr = clrs[num_col];
        string cnt = ctrs[num_con];
        string tpe = tps[num_type];
        int F = rand() % 100 + 1;
        int M = rand() % 100 + 1;
        int wei = rand() % 100 + 1;
        int cal = rand() % 100 + 1;
        int vA = rand() % 100;
        int vB = rand() % 100;
        int vC = rand() % 100;
        set_apple(clr , tpe , cnt , wei , cal , F , M , vA , vB , vC);
    }
    // получаем данные о нашем объекте
    void get_all_info() {
        cout << "--------------------------------\n";
        cout << "актуальная информация: \n";
        cout << "color: " << color << "\n";
        cout << "type: " << type << "\n";
        cout << "country: " << country << "\n";
        cout << "weight: " << weight << "\n";
        cout << "kcal: " << kcal << "\n";
        cout << "Fe: " << Fe << "\n";
        cout << "Mg: " << Mg << "\n";
        cout << "vitA: " << vitA << "\n";
        cout << "vitB: " << vitB << "\n";
        cout << "vitC: " << vitC << "\n";
        cout << "--------------------------------\n";
        // to add other parameters;
    }
    // устанливаем цвет объекта
    void set_color(string cl) {
        cout << "тип объекта установлен\n";
        color = cl;
    }
    // устанливаем тип объекта
    void set_type(string tp) {
        cout << "тип объекта установлен\n";
        type = tp;
    }
    // устанливаем страну объекта
    void set_country(string count) {
        cout << "страна происхождения объекта установлена\n";
        country = count;
    }
    // устанливаем массу объекта
    void set_weight(int wei) {
        cout << "вес объекта установлен\n";
        weight = wei;
    }
    // устанливаем калории объекта
    void set_kcal(int cal) {
        cout << "число калорий объекта установлен\n";
        kcal = cal;
    }
    // устанливаем содержание железа в объекте
    void set_Fe(int F) {
        cout << "содержание железа в объекте установлено\n";
        Fe = F;
    }
    // устанливаем содержание магния в объекте
    void set_Mg(int M) {
        cout << "содержание магния в объекте установлено\n";
        Mg = M;
    }
    // устанливаем содержание витамина А в объекте
    void set_vitA(int A) {
        cout << "содержание витамина А в объекте установлено\n";
        vitA = A;
    }
    // устанливаем содержание витамина B в объекте
    void set_vitB(int B) {
        cout << "содержание витамина B в объекте установлено\n";
        vitB = B;
    }
    // устанливаем содержание витамина C в объекте
    void set_vitC(int C) {
        cout << "содержание витамина C в объекте установлено\n";
        vitC = C;
    }
    // получаем только тип
    void get_type() {
        cout << "тип объекта\n";
        cout << "type: " << type << "\n";
    }
    // получаем только цвет
    void get_color() {
        cout << "цвет объекта\n";
        cout << "color: " << color << "\n";
    }
    // получаем только страну
    void get_country() {
        cout << "страна происхождения\n";
        cout << "country: " << country << "\n";
    }
    // получаем только массу
    void get_weight() {
        cout << "масса объекта\n";
        cout << "weight: " << weight << "\n";
    }
    // получаем только калории
    void get_kcal() {
        cout << "калории в объекте\n";
        cout << "kcal: " << kcal << "\n";
    }
    // получаем только содержание железа
    void get_Fe() {
        cout << "содержание железа в объекте\n";
        cout << "Fe: " << Fe << "\n";
    }
    // получаем только содержание магния
    void get_Mg() {
        cout << "содержание магния в объекте\n";
        cout << "Mg: " << Mg << "\n";
    }
    // получаем только содержание витамина А
    void get_vitA() {
        cout << "содержание витамина А в объекте\n";
        cout << "vitA: " << vitA << "\n";
    }
    // получаем только содержание витамина B
    void get_vitB() {
        cout << "содержание витамина B в объекте\n";
        cout << "vitB: " << vitB << "\n";
    }
    // получаем только содержание витамина C
    void get_vitC() {
        cout << "содержание витамина C в объекте\n";
        cout << "vitC: " << vitC << "\n";
    }
    // выводит всю информацию о классе в файлик с соответствующим именем объекта класса
    void to_xml(string name) {
        ofstream fout;
        name += ".xml";
        fout.open(name);
        fout << "--------------------------------\n";
        fout << "актуальная информация: \n";
        fout << "color: " << color << "\n";
        fout << "type: " << type << "\n";
        fout << "country: " << country << "\n";
        fout << "weight: " << weight << "\n";
        fout << "kcal: " << kcal << "\n";
        fout << "Fe: " << Fe << "\n";
        fout << "Mg: " << Mg << "\n";
        fout << "vitA: " << vitA << "\n";
        fout << "vitB: " << vitB << "\n";
        fout << "vitC: " << vitC << "\n";
        fout << "--------------------------------\n";
        fout.close();
    }
    // деструктор
    ~apple() {
        cout << "деструктор сработал!\n";
    }

};
// дочерний класс ананас
class pineapple : public apple {
private: int *x;
public:
    pineapple() : apple() {
        // выделили память!
        x = new int;
    }
    void increase_value() {
        value++;
        // благодаря protected теперь дочерний класс pineapple имеет право доступа к value из apple
    }
    ~pineapple() {
        // очистили память!
        delete x;
        cout << "pineapple was destructed\n";
    }
    // установить загадочное х в ананасе
    void set_x(int p) {
        *x = p;
    }
    // получить загадочное х в ананасе
    void get_x() {
        cout << *x << ": current value\n";
    }
};
const apple operator+(const apple& left, const apple& right) {
    string coun = min(left.country, right.country) + " or " + max(left.country , right.country);
    string clr = min(left.color, right.color) + " or " + max(left.color , right.color);
    string type = min(left.type, right.type) + " or " + max(left.type , right.type);
    int F = left.Fe + right.Fe;
    int M = left.Mg + right.Mg;
    int wei = left.weight + right.weight;
    int cal = left.kcal + right.kcal;
    int vA = left.vitA + right.vitA;
    int vB = left.vitB + right.vitB;
    int vC = left.vitC + right.vitC;
    return apple(clr , type , coun , wei , cal , F , M , vA , vB , vC);
}
const apple operator*(const apple& left, const apple& right) {
    string coun = min(left.country, right.country) + " and " + max(left.country , right.country);
    string clr = min(left.color, right.color) + " and " + max(left.color , right.color);
    string type = min(left.type, right.type) + " and " + max(left.type , right.type);
    int F = left.Fe * right.Fe;
    int M = left.Mg * right.Mg;
    int wei = left.weight * right.weight;
    int cal = left.kcal * right.kcal;
    int vA = left.vitA * right.vitA;
    int vB = left.vitB * right.vitB;
    int vC = left.vitC * right.vitC;
    return apple(clr , type , coun , wei , cal , F , M , vA , vB , vC);
}
ostream& operator<<(ostream& os, const apple& app) {
    os << "--------------------------------\n";
    os << "актуальная информация: \n";
    os << "color: " << app.color << "\n";
    os << "type: " << app.type << "\n";
    os << "country: " << app.country << "\n";
    os << "weight: " << app.weight << "\n";
    os << "kcal: " << app.kcal << "\n";
    os << "Fe: " << app.Fe << "\n";
    os << "Mg: " << app.Mg << "\n";
    os << "vitA: " << app.vitA << "\n";
    os << "vitB: " << app.vitB << "\n";
    os << "vitC: " << app.vitC << "\n";
    os << "--------------------------------\n";
    return os;
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    setlocale(LC_ALL, "rus");
    srand(time(0));
    string cl, tp, ctr;
    int Fe, Mg, kcal, weight, vitA, vitB, vitC;
    cl = "red";
    tp = "apple";
    ctr = "Russia";
    weight = 10;
    kcal = 34;
    Fe = 23;
    Mg = 24;
    vitA = 14;
    vitB = 98;
    vitC = 67;
    apple x;
    // удобная инициализация нового яблока случайным образом
    x.set_rand_apple();
    // вывсести актулальную информацию
    x.get_all_info();
    // вывод той же информации непосредственно через перегрузку операции '<<'
    cout << x;
    // пример для конструктора с двумя начальными данными
    apple app(cl , tp);
    // пример для конструктора если известен только цвет
    apple app_clr(cl);
    // пример для конструктора по умолчанию
    apple st;
    // перегрузка сложения
    cout << app + x;
    // перегрузка умножения
    cout << app * x << "\n";
    // проверка всех set/get
    //цвет
    st.set_color(cl);
    st.get_color();
    //тип
    st.set_type(tp);
    st.get_type();
    // страна производства
    st.set_country(ctr);
    st.get_country();
    // вес
    st.set_weight(weight);
    st.get_weight();
    // калории
    st.set_kcal(kcal);
    st.get_kcal();
    // содержание железа
    st.set_Fe(Fe);
    st.get_Fe();
    // содержание магния
    st.set_Mg(Mg);
    st.get_Mg();
    // содержание витамина А
    st.set_vitA(vitA);
    st.get_vitA();
    // содержание витамина B
    st.set_vitB(vitB);
    st.get_vitB();
    // содержание витамина C
    st.set_vitC(vitC);
    st.get_vitC();
    //(список стран, откуда происходит рандомное распределение)
    st.get_ctrs();
    //(список цветов, откуда происходит рандомное распределение)
    st.get_clrs();
    //(список типов, откуда происходит рандомное распределение)
    st.get_tps();
    // чтобы отчистить словарь стран цветов или типов   st.clear_countries()   st.clear_colors()   st.clear_types()
    st.clear_types();
    vector<string> to_add;
    cout << "введите размер словаря стран,на который вы хотите заменить старый словарь и затем введите n стран \n";
    int n;
    cin >> n;
    for(int i = 0; i < n; i++) {
        string cur;
        cin >> cur;
        to_add.push_back(cur);
    }
    st.new_countries(to_add);
    to_add.clear();
    cout << "введите размер словаря цветов,на который вы хотите заменить старый словарь и затем введите n цветов \n";
    cin >> n;
    for(int i = 0; i < n; i++) {
        string cur;
        cin >> cur;
        to_add.push_back(cur);
    }
    st.new_colors(to_add);
    to_add.clear();
    cout << "введите размер словаря типов,на который вы хотите заменить старый словарь и затем введите n типов \n";
    cin >> n;
    for(int i = 0; i < n; i++) {
        string cur;
        cin >> cur;
        to_add.push_back(cur);
    }
    st.new_types(to_add);
    // вывод существующего объекта класса и информации о нем с соответвующий файлик .xml
    st.to_xml("st");
    pineapple piney ;
    piney.set_x(123);
    piney.get_x();
    return 0;
}