class Helper {
  static newMergeData(oldData, newData) {
    // console.groupCollapsed('oldData, newData');
    // console.log(oldData,newData);
    // console.groupEnd();

    const newObj = {
      utakmice: {}, //oldData.utakmice, // {IDUtakmica:{Utakmica}}
      oklade: {}, //oldData.oklade, // {IDOklada:{Oklada}}
      koeficijenti: {}, //oldData.koeficijenti,// {IDKoeficijent:{Koeficijent}}
      Koeficijenti: newData.K // {IDOklada:{IDKoeficijent:{Koeficijent}}}
    };
    // console.log("newObj", newObj)
    // console.log("OLdATA",oldData.utakmice)

    // console.log("koefcijenti", oldData.koeficijenti)
    // console.log("Koefcijenti",newData.K)

    const newUtakmice = {
      D: newData.UtakmiceD || [], // [UtakmiceD]
      T: newData.UtakmiceT || [] // [UtakmiceT]
    };

    // console.log("newDataUtakmiceT", newData.UtakmiceT)
    // console.log("UtakmiceD", newData.UtakmiceD)
    // console.log("newUtakmice", newUtakmice);

    // console.log(newData.UtakmiceD || []);
    const newOklade = {
      D: newData.OkladeD || [], // [OkladeD]
      T: newData.OkladeT || [] // [OKladeT]
    };

    // console.log("okladeD",newData.OkladeD)
    // console.log("okladeD",newData.OkladeT)
    // console.log("NewData.OkladeD",newData.OkladeD || [])
    // console.log("neData.OkladeT", newData.OkladeT || [])
    // console.log("newOklade", newOklade)
    const newKoeficijenti = {
      K: newData.Koeficijenti || [], // [Koeficijenti]
      k: newData.K || {} // {IDOklada:{IDKoeficijent:{Koeficijent}}}
    };

    // console.log("newKoefcijenti", newKoeficijenti)
    // console.log("newData.Koefcijenti", newData.Koeficijenti)
    // console.log("newData.Koegcijenti", newData.Koeficijenti || [])
    // console.log("newData k ", newData.K || []);

    // UTAKMICE
    //   Object.values(oldData.utakmice).forEach(utk => {
    //     const keys = [...this.keys.UtakmiceD, ...this.keys.UtakmiceT];
    //     newObj.utakmice[utk.IDUtakmica] = newObj.utakmice[utk.IDUtakmica] || [];
    //     keys.forEach(key => {
    //       newObj.utakmice[utk.IDUtakmica][key] = utk[key];
    //      // console.log("keyc", newObj.utakmice[utk.IDUtakmica][key] = utk[key])

    //     });
    //  //  console.log("utakmiceIDUTAKMICEUTAKMICEUTAKMICEUTAKMICE", newObj.utakmice[utk.IDUtakmica] || {})
    //   });

    // console.log("olData.utakmice", oldData.utakmice)
    // console.log("this keys Utakmice D", ...this.keys.UtakmiceD)
    // console.log("this keys uTAKMICET", ...this.keys.UtakmiceT)
    // console.log("keys", [...this.keys.UtakmiceD, ...this.keys.UtakmiceT])
    // console.log("utk.IDUtakmica", newObj.utakmice)

    newUtakmice.D.forEach(utk => {
      const keys = this.keys.UtakmiceD;
      newObj.utakmice[utk.IDUtakmica] = newObj.utakmice[utk.IDUtakmica] || {};
      //console.log(" newObj.utakmice[utk.IDUtakmica", newObj.utakmice[utk.IDUtakmica] || {})

      keys.forEach(key => {
        newObj.utakmice[utk.IDUtakmica][key] = utk[key];

        // console.log(
        //   " newObj.utakmice[utk.IDUtakmica][key] ",
        //   newObj.utakmice[utk.IDUtakmica][key]
        // );
      });
    });

    // console.log("newUtakmice.D", newUtakmice.D);

    newUtakmice.T.forEach(utk => {
      const keys = this.keys.UtakmiceT;
      newObj.utakmice[utk.IDUtakmica] = newObj.utakmice[utk.IDUtakmica] || {};
      // console.log(" newObj.utakmice[utk.IDUtakmica] || {};", newObj.utakmice[utk.IDUtakmica] || {})
      keys.forEach(key => {
        newObj.utakmice[utk.IDUtakmica][key] = utk[key];
        //console.log("newObj.utakmice[utk.IDUtakmica][key] = utk[key]", newObj.utakmice[utk.IDUtakmica][key] = utk[key])
      });
    });

    //console.log("newUtakmice.T", newUtakmice.T);
    let arr = newObj.utakmice;
    Object.keys(newObj.utakmice).forEach((key, index) => {
      if (
        !arr[key].Aktivno ||
        !arr[key].AktivnoW ||
        arr[key].UTijeku === 2 ||
        !arr[key]
          .EkranAktivan /*(!arr[key].KladjenjeAktivno && !arr[key].EkranAktivan)*/
      ) {
        delete newObj.utakmice[key];
      }
      // console.log("Object,keys",Object.keys(newObj.utakmice))
      // console.log("newObjkat Utakmice ",newObj.utakmice[key])
    });

    //OKLADE
    Object.values(oldData.oklade).forEach(okl => {
      const keys = [...this.keys.OkladeD, ...this.keys.OkladeT];
      newObj.oklade[okl.IDOklada] = newObj.oklade[okl.IDOklada] || {};
      keys.forEach(key => {
        newObj.oklade[okl.IDOklada][key] = okl[key];

        // console.log("olData.oklade", oldData.oklade)
        // console.log("newObj", newObj.oklade);

        // console.log(
        //   "newObj.oklade[okl.IDOklada][key]",
        //   newObj.oklade[okl.IDOklada][key]
        // );

        // console.log("newObjekat" , okl[key])
      });
    });

    newOklade.D.forEach(okl => {
      const keys = this.keys.OkladeD;
      newObj.oklade[okl.IDOklada] = newObj.oklade[okl.IDOklada] || {};
      keys.forEach(key => {
        newObj.oklade[okl.IDOklada][key] = okl[key];
      });
    });
    newOklade.T.forEach(okl => {
      const keys = this.keys.OkladeT;
      newObj.oklade[okl.IDOklada] = newObj.oklade[okl.IDOklada] || {};
      keys.forEach(key => {
        newObj.oklade[okl.IDOklada][key] = okl[key];
      });
    });

    arr = newObj.oklade;
    Object.keys(newObj.oklade).forEach((key, index) => {
      if (
        !arr[key].Aktivno ||
        !arr[key].Prikazati ||
        !arr[key].PozicijaID ||
        arr[key].PozicijaID > 5 ||
        !arr[key].Red ||
        arr[key].Red < 1 ||
        arr[key].Red > 3
      ) {
        delete newObj.oklade[key];
      }
    });

    // KOEFICIJENT
    newKoeficijenti.K.forEach(koef => {
      const keys = this.keys.Koeficijenti;
      newObj.koeficijenti[koef.IDKoeficijent] =
        newObj.koeficijenti[koef.IDKoeficijent] || {};
      keys.forEach(key => {
        newObj.koeficijenti[koef.IDKoeficijent][key] = koef[key];
      });
    });

    arr = newObj.koeficijenti;
    Object.keys(newObj.koeficijenti).forEach((key, index) => {
      if (!arr[key].Aktivno || !arr[key].Prikazati || !arr[key].Redoslijed) {
        delete newObj.koeficijenti[key];
      }
    });

    let Koeficijenti = Helper.newCombineTwoKoeficijenta(
      oldData.Koeficijenti, // {IDOklada:{IDKoeficijent:{Koeficijent}}}
      Object.values(newObj.koeficijenti) || [], // {IDOklada: {IDKoeficijent:{Koeficijent}}}
      "OkladaID",
      "IDKoeficijent"
    );

    // const finalOklade = this.mapOklade( // return {IDUtakmica:{PozicijaID:{Red:{calcRed:''}}}}
    //   newObj.oklade, // {IDOklada:{Oklada}}
    //   Koeficijenti,  // {IDOklada:{IDKoeficijent:{Koeficijent}}}
    //   oldData.finalOklade // {IDUtakmica:{PozicijaID:{Red:{calcRed:''}}}}
    // );

    const finalOklade = this.newMapOklade(
      // return {IDUtakmica:{PozicijaID:{Red:{calcRed:''}}}}
      newObj.oklade, // {IDOklada:{Oklada}}
      Koeficijenti, // {IDOklada:{IDKoeficijent:{Koeficijent}}}
      oldData.finalOklade // {IDUtakmica:{PozicijaID:{Red:{calcRed:''}}}}
    );
    // console.log("finaloklade", finalOklade);

    // console.log(
    // oldData,
    // newData
    // newObj
    // newUtakmice,
    // newOklade
    // newKoeficijenti
    // finalOklade
    // );

    return {
      ...oldData,
      ...newObj,
      finalOklade,
      Koeficijenti: Koeficijenti
    };
  }
  static keys = {
    UtakmiceD: [
      "Aktivno",
      "AktivnoW",
      "Ekran",
      "EkranAktivan",
      "IDUtakmica",
      "Jezik",
      "KladjenjeAktivno",
      "KladjenjeAktivnoW",
      "SpecFlagsDomacin",
      "SpecFlagsGost",
      "TenisRezultat",
      "TenisRezultatAktivni",
      "TenisRezultatSet",
      "TrenutniRezultatUtakmiceDomacin",
      "TrenutniRezultatUtakmiceGost",
      "TrenutnoVrijemeUtakmice",
      "UTijeku",
      "UpdateStamp"
    ],
    UtakmiceT: [
      "PeriodUtakmice",
      "SportID",
      "TVSifra",
      "TimDomacinNaziv",
      "TimGostNaziv",
      "TrenutniStatusUtakmiceID",
      "VrijemePocetkaUtakmice"
    ],
    OkladeD: [
      "Aktivno",
      "Cleared",
      "Ekran",
      "IDOklada",
      "Omoguciti",
      "Prikazati",
      "UpdateStamp",
      "UpdateTimeSec",
      "UtakmicaID",
      "calcRed"
    ],
    OkladeT: [
      "DugiNaziv",
      "Jezik",
      "KategorijaPonudeID",
      "Naziv",
      "PosebanaVrijednost",
      "PozicijaID",
      "Red",
      "SifraOklade",
      "VrstaOkladeID",
      "SpanReda"
    ],
    Koeficijenti: [
      "Aktivno",
      "Ekran",
      "IDKoeficijent",
      "Jezik",
      "Naziv",
      "OkladaID",
      "Omoguciti",
      "Prikazati",
      "Redoslijed",
      "TVTipKucanje",
      "TipOkladeID",
      "UpdateStamp",
      "UtakmicaID",
      "Vrijednost",
      "calcOrd"
    ]
  };
  static mergeData(state, newData) {
    let tempData = state;
    let utakmice = tempData.utakmice;
    let oklade = tempData.oklade;
    let koeficijenti = tempData.Koeficijenti;

    // rasclanjuje objekte u varijable
    let UtakmiceD = this.convertToObj(newData.UtakmiceD, "IDUtakmica");
    let UtakmiceT = this.convertToObj(
      [...Object.values(state.UtakmiceT), ...newData.UtakmiceT],
      "IDUtakmica"
    );

    // console.log("utakmiceeeeeeeee", UtakmiceT);

    let OkladeD = this.convertToObj(newData.OkladeD || [], "IDOklada");
    let OkladeT = this.convertToObj(
      [...Object.values(state.OkladeT), ...(newData.OkladeT || [])],
      "IDOklada"
    );

    // sve utakmice koje smo do sada obradili
    let UtakmiceALL = utakmice;
    let OkladeALL = oklade;

    utakmice = {};
    oklade = {};

    // keyevi iz objekata za utakmcie
    const UtakmiceKeys = this.getKeys(UtakmiceD, UtakmiceALL);
    const OkladeKeys = this.getKeys(OkladeD, OkladeT, OkladeALL);

    // spajamo iz 3 varijable vrijednstu u utakmica[key]
    UtakmiceKeys.forEach(key => {
      utakmice[key] = {};
      utakmice[key] = this.deepMergeObjects(
        UtakmiceALL[key],
        UtakmiceT[key],
        1
      );
      utakmice[key] = this.deepMergeObjects(utakmice[key], UtakmiceD[key], 2);
    });

    OkladeKeys.forEach(key => {
      oklade[key] = {};
      oklade[key] = this.deepMergeObjects(OkladeALL[key], OkladeT[key], 1);
      oklade[key] = this.deepMergeObjects(oklade[key], OkladeD[key], 2);
    });

    let finalOklade = this.mapOklade(
      oklade,
      koeficijenti,
      tempData.finalOklade
    );

    // cistimo utakmice koje su zavrsile/ nisu aktivne
    this.getKeys(utakmice).forEach(key => {
      if (
        !utakmice[key].Aktivno ||
        !utakmice[key].AktivnoW ||
        //utakmice[key].TrenutnoVrijemeUtakmice === "FT"
        !utakmice[key].UTijeku === 1 //
      ) {
        delete utakmice[key];
      }
    });

    return {
      ...state,
      utakmice,
      oklade,
      finalOklade,
      Koeficijenti: koeficijenti
    };
  }

  // mapira IDOklade u IDUtakmice i pozicionira po dubini
  static mapOklade(oklade, koeficijenti, finalOkladeObj) {
    // {IDOKlada:{Oklada}},
    // {IDOklada:{IDKoeficijent:{Koeficijent}}}
    // {IDUtakmica:{MATRICA}}
    let OkladeValues = Object.values(oklade);

    let okaldeByUtakmice = {};
    let finalOkladeState = {};
    this.getKeys(this.convertToObj(OkladeValues, "UtakmicaID")).forEach(key => {
      okaldeByUtakmice[key] = [];
      finalOkladeState[key] = {};
    });

    OkladeValues.forEach(oklada => {
      let UniqueVrstaOkladeID = okaldeByUtakmice[oklada.UtakmicaID].filter(
        utk =>
          utk.VrstaOkladeID !== oklada.VrstaOkladeID ||
          (utk.VrstaOkladeID === oklada.VrstaOkladeID && utk.Aktivno === true)
      );
      if (oklada.Aktivno === true) {
        UniqueVrstaOkladeID.push(oklada);
      }
      okaldeByUtakmice[oklada.UtakmicaID] = UniqueVrstaOkladeID;
    });

    Object.keys(okaldeByUtakmice).forEach(key => {
      let oklade = okaldeByUtakmice[key];
      finalOkladeState[key] =
        finalOkladeObj[key] || this.getEmptyOkladaObject();

      // filtriramo oklade koje ne treba prikazati
      oklade = oklade.filter(
        okl =>
          !(
            okl.PozicijaID > 5 ||
            // okl.calcRed !== 0 ||
            okl.Aktivno === false
          )
        // okl.AktivnoW === false ||
        //okl.Cleared !== 0
      );
      oklade.forEach(okl => {
        try {
          finalOkladeState[key][okl.PozicijaID][okl.Red][0] =
            okl.PosebanaVrijednost;

          if (Object.values(koeficijenti[okl.IDOklada] || {}).length) {
            let keys = Object.keys(koeficijenti[okl.IDOklada]).filter(tmpKey =>
              (tmpKey || "").match(/^[0-9]+$/)
            );
            keys.forEach(tmpKey => {
              finalOkladeState[key][okl.PozicijaID][okl.Red][
                koeficijenti[okl.IDOklada][tmpKey]["Redoslijed"]
              ] =
                // cl-gray
                (koeficijenti[okl.IDOklada][tmpKey]["Omoguciti"] !== false
                  ? "1"
                  : "2") +
                // cl-transparent
                (koeficijenti[okl.IDOklada][tmpKey]["Prikazati"] !== false
                  ? "1"
                  : "2") +
                this.formatNumber2decs(
                  koeficijenti[okl.IDOklada][tmpKey]["Vrijednost"].toString()
                );
            });
          }
        } catch (e) {
          // console.log(
          //   okl,
          //   koeficijenti[okl.IDOklada],
          //   finalOkladeState[key],
          //   e
          // );
        }
      });
    });

    return finalOkladeState;
  }
  static newMapOklade(oklade, koeficijenti, oldObj) {
    // {IDOKlada:{Oklada}},
    // {IDOklada:{IDKoeficijent:{Koeficijent}}}
    // {IDUtakmica:{MATRICA}}

    // ZA PROVJERU RADI LAKSEG RADA
    Object.keys(oklade).forEach(key => {
      const IDUtakmica = oklade[key].UtakmicaID;
      const sameOklade = Object.values(oklade).filter(
        okl => okl.UtakmicaID === IDUtakmica
      );
      const sameKoef = Object.values(koeficijenti).filter(koef => {
        const keys = sameOklade
          .map(okl => okl.IDOklada)
          .filter(key => key === koef.OkladaID);
        return !!keys.length;
      });
      console.log(IDUtakmica, sameOklade, sameKoef);
    });

    const newObj = {};

    Object.keys(koeficijenti).forEach(IDOklada => {
      if (!IDOklada || !oklade[IDOklada]) return;
      const IDUtakmica = oklade[IDOklada].UtakmicaID;
      const okl = oklade[IDOklada];
      const koefs = Object.values(koeficijenti[IDOklada]);

      if (!newObj[IDUtakmica]) {
        newObj[IDUtakmica] = this.getEmptyOkladaObject();
      }
      // console.log(koefs)
      koefs.forEach(koef => {
        let RED = +okl.Red + okl.calcRed;
         if((RED===3 || RED===2 || RED === 1)){
           RED = okl.Red;
         }else{
           if(RED===1 && okl.calcRed === 0){
           RED = 1;
           }else if(RED===1 && okl.calcRed === 1){
             RED=2;
           }else if(RED === 1 && okl.calcRed === 2){
             RED=3;
           }
         }


        // if (okl.DugiNaziv.startsWith("Broj ko")) {
        //   if (
        //     okl.DugiNaziv.indexOf("[d!]") !== -1 &&
        //     (RED !== 1 || okl.VrstaOkladeID !== 249)
        //   ) {
        //     RED = 0;
        //   } else if (
        //     okl.DugiNaziv.indexOf("[g!]") !== -1 &&
        //     (RED !== 2 || okl.VrstaOkladeID !== 250)
        //   ) {
        //     RED = 0;
        //   }
        // }

        if (
          okl.Aktivno &&
          !okl.Cleared &&
          okl.Prikazati &&
          RED > 0 &&
          RED < 4
        ) {
          // const RED = /*okl.SpanReda ===0 &&*/ okl.calcRed === 0?okl.Red : okl.SpanReda===okl.calcRed?okl.Red:Math.min(okl.Red+1,2);
          // console.log(koef,oldObj[IDUtakmica],okl,RED);

          // oldObj[IDUtakmica][okl['PozicijaID']][RED][0] = okl.PosebanaVrijednost;
          if (okl.PosebanaVrijednost) {
            newObj[IDUtakmica][okl["PozicijaID"]][RED][0] =
              okl.PosebanaVrijednost;
          }
          newObj[IDUtakmica][okl["PozicijaID"]][RED][
            koef["Redoslijed"]
          ] = koef.Prikazati
            ? `${koef.Omoguciti ? "1" : "2"}${
                koef.Prikazati ? "1" : "2"
              }${this.formatNumber2decs(koef.Vrijednost)}`
            : "";
        } else {
          // if (okl.PosebanaVrijednost) {
          //   newObj[IDUtakmica][okl["PozicijaID"]][RED][0] =
          //     okl.PosebanaVrijednost;
          // }
          newObj[IDUtakmica][okl["PozicijaID"]][RED] = {
            0: "",
            1: "",
            2: "",
            3: "",
            4: ""
          };
          // newObj[IDUtakmica][okl["PozicijaID"]][RED][koef["Redoslijed"]] = "";
        }
      });
    });
    return newObj;
  }
  static formatNumber2decs(num) {
    num = num.toString();
    if (num.match(/^[0-9]+\.[0-9][0-9]$/)) {
      return num;
    } else {
      if (num.indexOf(".") === -1) {
        return num + ".00";
      } else {
        return num + "0";
      }
    }
  }

  // kreira prazan objekat za mapiranu okladu
  static getEmptyOkladaObject() {
    return {
      1: {
        1: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        2: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        3: { 0: "", 1: "", 2: "", 3: "", 4: "" }
      },
      2: {
        1: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        2: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        3: { 0: "", 1: "", 2: "", 3: "", 4: "" }
      },
      3: {
        1: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        2: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        3: { 0: "", 1: "", 2: "", 3: "", 4: "" }
      },
      4: {
        1: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        2: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        3: { 0: "", 1: "", 2: "", 3: "", 4: "" }
      },
      5: {
        1: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        2: { 0: "", 1: "", 2: "", 3: "", 4: "" },
        3: { 0: "", 1: "", 2: "", 3: "", 4: "" }
      }
    };
  }
  // vraca bez duplikata kombinovano sve kljuceve koji se pojavljuju u svim objektima
  static getKeys(...arr) {
    let keys = arr.map(element => Object.keys(element || {}));
    let allKeys = [];
    keys.forEach(key => {
      allKeys = [...allKeys, ...key];
    });
    return [...new Set(allKeys)];
  }

  // provjerava jel definisana varijabla i vraca true ili undefined
  static isSet(val) {
    return val !== undefined || undefined;
  }
  // filtrira duple elemente iz nizova po key
  static filterData(data, key) {
    let newData = [];
    while (data.length) {
      let currItem = data.splice(0, 1)[0];
      let currElements = data.filter(element => element[key] === currItem[key]);
      if (currElements.length) {
        newData.push(currElements.pop());
        currElements.forEach(el => {
          let ix = data.indexOf(el);
          if (ix !== -1) data.splice(ix, 1);
        });
      } else {
        newData.push(currItem);
      }
    }
    return newData;
  }

  // pretvara niz u objekat po key
  static convertToObj(data, key) {
    let newData = {};
    data.forEach(el => (newData[el[key]] = el));
    return newData;
  }

  static deepMergeObjects(object1 = {}, object2 = {}) {
    const keys = this.getKeys(object1, object2);
    let tempObj = {};
    keys.forEach(k => {
      if (
        object1[k] !== undefined &&
        (!object2[k] || object2[k] === undefined)
      ) {
        tempObj[k] = object1[k];
      } else {
        tempObj[k] = object2[k];
      }
    });
    return tempObj;
  }

  // return random number
  static getRandom() {
    return Math.round(Math.random() * Date.now() * Math.random());
  }
  // shallow merge o2 over o1
  //vrijedi za sve
  static mergeObjects(object1, object2) {
    return { ...object1, ...object2 };
  }

  // merger a2 into a1
  static mergeArray(array1, array2) {
    return [...array1, ...array2];
  }

  // merge two arrays i vraca vrijednosti bez duplikata
  static mergeSet(array1, array2) {
    return [...new Set([...array1, ...array2])];
  }

  // pretvara objekat u array vrijednosti
  static convertToArray(obj) {
    return Object.values(obj);
  }

  // static combineTwoKoeficijenta(array1, array2, key1, key2) {
  //   let combined = {};
  //   let arr = [];
  //   arr.push(array1);
  //   arr.push(array2);
  //   arr.forEach(a => {
  //     a.forEach(value => {
  //       if (combined[value[key1]]) {
  //         combined[value[key1]] = {
  //           ...combined[value[key1]],
  //           [value[key2]]: value
  //         };
  //       } else {
  //         if (value[key1] === undefined) {
  //           // || val[key2] === undefined) {
  //           Object.values(value).forEach(element => {
  //             if (combined[element[key1]]) {
  //               combined[element[key1]] = {
  //                 ...combined[element[key1]],
  //                 [element[key2]]: element
  //                 // [val[key2]]: el
  //               };
  //             } else {
  //               combined[element[key1]] = {
  //                 [element[key2]]: element
  //               };
  //             }
  //           });
  //         } else {
  //           combined[value[key1]] = {
  //             ...combined[value[key1]],
  //             [value[key2]]: value
  //           };
  //         }
  //       }
  //     });
  //   });
  //   return combined;
  // }

  static newCombineTwoKoeficijenta(oldObj, newArr, key1, key2) {
    // u combined cuvamo staru raspodjelu koeficijnata;
    const combined = {}; // oldObj;
    // prolazimo kroz nove koeficijente
    newArr.forEach(koef => {
      // ako ne postroji oklada kreiramo je kao {IDOklade:{IDKoeficijenta:{Koeficijent}}}
      if (!combined[koef[key1]]) {
        combined[koef[key1]] = {
          [koef[key2]]: koef
        };
      } else {
        // ako  postroji oklada dopunjavamo je  {IDOklade:{IDKoeficijenta:{Koeficijent},IDKoeficijenta:{Koeficijent},...}}

        combined[koef[key1]] = {
          ...combined[koef[key1]],
          [koef[key2]]: koef
        };
      }
    });
    // vracamo kombinaciju starih i novih koeficijenata
    return combined;
  }

  // static rasclaniAndVrijednost(val, slova = ['g', 's']) {
  //   const regexp = /(\d)+-(\d)+and(\d)+/;
  //   let res = regexp.exec(val);
  //   if (res !== null) {
  //     return `${res[2] === "0" ? 10 : res[2]},${
  //       res[3] === 0 ? 10 : res[2] === "0" ? 1 + "" + res[3] : res[3]
  //       }${slova[0]}-${res[1]}${slova[1]}`;
  //   } else {
  //     return null;
  //   }

  // }

  static newRasclani(val, template) {
    let tmpPosebna = val;
    let specNaz = template;

    console.log("tmpPosebna", val);
    if (tmpPosebna.indexOf("-") > 0 && tmpPosebna.indexOf("/-") === -1) {
      let tmpstring = tmpPosebna.replace("and", "-").split("-");
      let indReplace = 1;

      tmpstring.forEach(tmp => {
        specNaz = specNaz.replace(indReplace.toString() + "$", tmp);
        indReplace++;
      });
    } else {
      let tmpstring = tmpPosebna.split("/");
      let indReplace = 1;

      tmpstring.forEach(tmp => {
        specNaz = specNaz.replace(indReplace.toString() + "$", tmp);
        indReplace++;
      });
    }

    return specNaz;
  }

  static flatObject(obj) {
    let temp = Object.values(obj);
    let temp2 = [];
    temp.forEach(t => {
      temp2 = [...temp2, ...Object.values(t)];
    });
    let temp3 = [];
    temp2.forEach(t => {
      temp3 = [...temp3, ...Object.values(t)];
    });
    return temp3;
  }
  static rasclaniOKladeIdatu(oklada, id) {
    let niz = [oklada[0], oklada[1], oklada.slice(2)];
    return niz[id];
  }
  // id === 2 za vrijednosti // id === 1 za klase
  // static rasclaniObjekatOklada(oklade, id = 2) {
  //   let newObj = Helper.getEmptyOkladaObject();
  //   try {
  //     Object.keys(oklade).forEach(key1 => {
  //       Object.keys(oklade[key1]).forEach(key2 => {
  //         Object.keys(oklade[key1][key2]).forEach(key3 => {
  //           // omoguci
  //           // prikazi
  //           // vrijednost
  //           // [1][2](2.12)
  //           if (newObj[key1][key2][key3] === null) {
  //             newObj[key1][key2][key3] = null;
  //           } else if (id === 2)
  //             if (oklade[key1][key2][key3] === null) {
  //               newObj[key1][key2][key3] = null;
  //             } else if (`${key3}` === "0") {
  //               newObj[key1][key2][key3] = oklade[key1][key2][key3];
  //             } else {
  //               newObj[key1][key2][key3] = oklade[key1][key2][key3].slice(2);
  //             }
  //           else if (
  //             id === 1 &&
  //             oklade[key1][key2][key3] !== null //&&
  //           ) {
  //             let cls =
  //               oklade[key1][key2][key3][0] === "2" &&
  //               oklade[key1][key2][key3].length > 5
  //                 ? " cl-grey "
  //                 : "";
  //             cls +=
  //               oklade[key1][key2][key3][1] === "2" &&
  //               oklade[key1][key2][key3].length > 5
  //                 ? " cl-transparent "
  //                 : "";
  //             // cls +=
  //             //   oklade[key1][key2][key3].length < 3 ? " cl-transparent " : "";
  //             newObj[key1][key2][key3] = cls;
  //           } else if (id !== 1 && id !== 2) {
  //             console.error("Invalid id value: ", id);
  //             return Helper.getEmptyOkladaObject();
  //           }
  //         });
  //       });
  //     });
  //   } catch (e) {
  //     console.log(e, oklade, newObj, id);
  //   }
  //   return newObj;
  // }

  // id === 2 za vrijednosti // id === 1 za klase
  static rasclaniObjekatOklada(oklade, id = 2) {
    let newObj = Helper.getEmptyOkladaObject();
    try {
      Object.keys(oklade).forEach(key1 => {
        Object.keys(oklade[key1]).forEach(key2 => {
          Object.keys(oklade[key1][key2]).forEach(key3 => {
            // omoguci
            // prikazi
            // vrijednost
            // [1][2](2.12)
            if (newObj[key1][key2][key3] === null) {
              newObj[key1][key2][key3] = null;
            } else if (id === 2)
              if (oklade[key1][key2][key3] === null) {
                newObj[key1][key2][key3] = null;
              } else if (`${key3}` === "0") {
                newObj[key1][key2][key3] = oklade[key1][key2][key3];
              } else {
                newObj[key1][key2][key3] = oklade[key1][key2][key3].slice(2);
              }
            else if (
              id === 1 &&
              oklade[key1][key2][key3] !== null //&&
            ) {
              let cls =
                oklade[key1][key2][key3][0] === "2" &&
                oklade[key1][key2][key3].length > 5
                  ? " cl-grey "
                  : "";
              cls +=
                oklade[key1][key2][key3][1] === "2" &&
                oklade[key1][key2][key3].length > 5
                  ? " cl-transparent "
                  : "";
              // cls +=
              //   oklade[key1][key2][key3].length < 3 ? " cl-transparent " : "";
              newObj[key1][key2][key3] = cls;
            } else if (id !== 1 && id !== 2) {
              console.error("Invalid id value: ", id);
              return Helper.getEmptyOkladaObject();
            }
          });
        });
      });
    } catch (e) {
      console.log(e, oklade, newObj, id);
    }
    return newObj;
  }

  static mapOldToNewObject(oldObj, oklade = this.getEmptyOkladaObject()) {
    const newObj = {};

    newObj.rowCode = {};
    newObj.rowCode.code = oldObj.TVSifra;
    newObj.rowCode.addditionalCode = ["A", "B"];

    newObj.matchData = {};

    newObj.matchData.currentSetScore = {};
    newObj.matchData.currentSetScore.first =
      oldObj.TrenutniRezultatUtakmiceDomacin;
    newObj.matchData.currentSetScore.second =
      oldObj.TrenutniRezultatUtakmiceGost;

    newObj.matchData.hasService = {};
    newObj.matchData.hasService.first = oldObj.SpecFlagsDomacin;
    newObj.matchData.hasService.second = oldObj.SpecFlagsGost;

    newObj.matchData.match = {};
    newObj.matchData.match.firstPlayer = oldObj.TimDomacinNaziv;
    newObj.matchData.match.secondPlayer = oldObj.TimGostNaziv;

    newObj.matchData.sport =
      // [0]
      this.sportConfig.filter(val => val.sportID === oldObj.SportID).naziv;
    newObj.matchData.timer = oldObj.TrenutnoVrijemeUtakmice;

    newObj.matchData.totalScore = {};
    newObj.matchData.totalScore.first = oldObj.TrenutniRezultatUtakmiceDomacin;
    newObj.matchData.totalScore.second = oldObj.TrenutniRezultatUtakmiceGost;

    newObj.matchData.setScore = {};
    newObj.matchData.setScore = oldObj.TenisRezultatSet;
    newObj.matchData.quotas = oklade;

    // for (let i = 1; i < 6; i++) {
    //   for (let j = 1; j < 3; j++) {
    //     for (let k = 0; k < 4; k++) {
    //       try {
    //         newObj.matchData.quotas.push(oklade[i][j][k]);
    //       } catch (e) {
    //         // console.log(i, j, k, oklade);
    //       }
    //     }
    //   }
    // }

    newObj.oldObj = { ...oldObj, oklade };
    return newObj;
  }

  static sportConfig = [
    {
      sportID: 1,
      naziv: "football",
      redoslijed: 1
    },
    {
      sportID: 5,
      naziv: "tennis",
      redoslijed: 2
    },
    {
      sportID: 2,
      naziv: "basketball",
      redoslijed: 3
    },
    {
      sportID: 23,
      naziv: "volleyball",
      redoslijed: 4
    },
    {
      sportID: 21,
      naziv: "beachVolleyball",
      redoslijed: 5
    },
    {
      sportID: 4,
      naziv: "hockey",
      redoslijed: 6
    }
  ];
  static formatDate(date) {
    let [datum, sati] = date.split(" ");
    let [d, m, g] = datum.split(".");
    let newDate = `${m}.${d}.${g} ${sati}`;
    return newDate;
  }
  static Jezici = {
    Tenis: {
      and: "$2,$3g-1$s",
      crtica: "1$g-2$s"
    }
  };
}

export default Helper;