function mainCalc(cat, totalCost, mainCost, length, tempRent, isRegisteredCitizen, calcElectricity, days) {
  let cost = 0.0;
  RETURN_CALC_COST.MAIN_COST = mainCost * days;
  if (isRegisteredCitizen) {
    cost -= mainCost * DISCOUNT_FOR_REGISTERED_CITIZEN;
    RETURN_CALC_COST.DISCOUNT_FOR_REGISTERED_CITIZEN += mainCost * DISCOUNT_FOR_REGISTERED_CITIZEN * days;
  }
  if (tempRent) {
    cost += mainCost * INCREASE_FOR_TEMP_RENT;
    RETURN_CALC_COST.INCREASE_FOR_TEMP_RENT = mainCost * INCREASE_FOR_TEMP_RENT * days;
  }

  cost += CLEANING_SERVICE * length;
  
  RETURN_CALC_COST.CLEANING_SERVICE = CLEANING_SERVICE * length * days;
  let WATER_SERVICE = getWaterCost(cat, length);
  cost += WATER_SERVICE;
  RETURN_CALC_COST.WATER_SERVICE += WATER_SERVICE * days;
  if (length >= 6 && calcElectricity) {
    let ELECTRICITY_SERVICE = parseFloat(getΕlectricityCost(length) / 365);
    cost += ELECTRICITY_SERVICE;
    RETURN_CALC_COST.ELECTRICITY_SERVICE += ELECTRICITY_SERVICE * days;
  }

  RETURN_CALC_COST.TOTAL_COST = totalCost + cost * days;
  return totalCost + cost * days;
}

function calculateSummer(mainCost, property, days) {
  let cost = mainCost;

  switch (property) {
    case 'business':
      cost -= mainCost * DISCOUNT_FOR_BUSINESS_USE_SUMMER;
      RETURN_CALC_COST.DISCOUNT_FOR_BUSINESS_USE += mainCost * DISCOUNT_FOR_BUSINESS_USE_SUMMER * days;
      break;
    default:
      break;
  }

  RETURN_CALC_COST.DAYS += days;
  RETURN_CALC_COST.DAYS_SUMMER += days;
  return cost * days;
}

function calculateWinter(cat, mainCost, property, days) {
  let cost = mainCost;
  switch (property) {
    case 'business':
      cost -= mainCost * DISCOUNT_FOR_BUSINESS_USE_WINTER;
      RETURN_CALC_COST.DISCOUNT_FOR_BUSINESS_USE += mainCost * DISCOUNT_FOR_BUSINESS_USE_WINTER * days;
      break;
    case 'relaxation':
      cost -= mainCost * DISCOUNT_FOR_RELAXATION_BUSINESS_USE;
      RETURN_CALC_COST.DISCOUNT_FOR_RELAXATION_BUSINESS_USE += mainCost * DISCOUNT_FOR_RELAXATION_BUSINESS_USE * days;
      break;
    default:
      if (cat == 'A') {
        cost -= mainCost * DISCOUNT_FOR_PRIVATE_USE;
        RETURN_CALC_COST.DISCOUNT_FOR_PRIVATE_USE += mainCost * DISCOUNT_FOR_PRIVATE_USE * days;
      }
      break;
  }

  RETURN_CALC_COST.DAYS += days;
  RETURN_CALC_COST.DAYS_WINTER += days;
  return cost * days;
}

function generateSeason() {
  for (let i = -50; i < 10; i++) {
    let year = CURRENT_YEAR + i;

    holdSeason[year] = {
      from: {
        'summer': convertDate(`${SUMMER_FROM.DAY}/${SUMMER_FROM.MONTH}/${year}`, true), // 04/01
        'winter': convertDate(`${WINTER_FROM.DAY}/${WINTER_FROM.MONTH}/${year}`, true), // 11/01
      },
      to: {
        'summer': convertDate(`${SUMMER_TO.DAY}/${SUMMER_TO.MONTH}/${year}`, false), // 10/31
        'winter': convertDate(`${WINTER_TO.DAY}/${WINTER_TO.MONTH}/${year}`, false), // 03/31
      }
    };
  }
}

function calcCostFromArray(costArray, length) {
  let max = 0;
  let found = false;
  Object.keys(costArray).forEach(len => {
    if (len !== 'additional' || len !== 'other') {
      len = parseInt(len);
      max = getMax(max, len);
      if (len == length) {
        found = costArray[len];
      }
    }
  });
  if (found) {
    return found;
  }
  let cost = 0;
  if (typeof costArray['additional'] !== 'undefined') {
    for (let i = max; i <= length; i++) {
      cost += (i === max) ? costArray[i] : costArray['additional'];
    }
  } else if (typeof costArray['other'] !== 'undefined') {
    cost = costArray['other'];
  }
  
  return cost;
}
function getVesselCost(cat, length) {
  const costArray = (cat == 'A') ? ARRAY_LENGTH_TO_PAY_CAT_A : ARRAY_LENGTH_TO_PAY_CAT_B;
  return calcCostFromArray(costArray, length);
}
function getWaterCost(cat, length) {
  const costArray = (cat == 'A') ? ARRAY_WATER_TO_PAY_CAT_A : ARRAY_WATER_TO_PAY_CAT_B;
  let a = calcCostFromArray(costArray, length);
  
  let main = WATER * a;
  let vat = main * WATER_VAT;
  let vatDrains = (main * WATER_DRAINS) * WATER_DRAINS_VAT;
  
  return (vat + vatDrains + WATER_CONSTANT)/365;
}
function getΕlectricityCost(length) {
  let a = calcCostFromArray(ARRAY_ELECTRICITY_TO_PAY, length);
  return (ELECTRICITY_CONSTANT + ELECTRICITY * a) * ELECTRICITY_VAT;
}

function returnCostFromDate(dateFrom, dateTo, categoryValue, vesselLengthValue, tempRentValue, isRegisteredCitizenValue, calcElectricityValue, propertyValue, days) {
  let cost = 0;
  let mainCost = getVesselCost((propertyValue == 'business') ? 'A' : categoryValue, vesselLengthValue);
  let found = false;
  Object.keys(holdSeason).forEach(year => {
    if (found) {
      return; // shqip if cost is calced;
    }
    // shqip previous and last year.. they are cached only for 'if statements'
    if (dateFrom.getUTCFullYear() > year) {
      return;
    }
    if (dateTo.getUTCFullYear() < year) {
      return;
    }
    
    let previous = parseInt(year) - 1;
    let next = parseInt(year) + 1;

    if (dateFrom.getUTCFullYear() == dateTo.getUTCFullYear()) {
      if (
        dateFrom >= holdSeason[year].from.summer &&
        dateFrom <= holdSeason[year].to.summer &&
        dateTo >= holdSeason[year].from.summer &&
        dateTo <= holdSeason[year].to.summer
      ) {
        cost = calculateSummer(mainCost, propertyValue, days);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.winter &&
        dateFrom <= holdSeason[next].to.winter &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter ||
        dateFrom >= holdSeason[previous].from.winter &&
        dateFrom <= holdSeason[year].to.winter &&
        dateTo >= holdSeason[previous].from.winter &&
        dateTo <= holdSeason[year].to.winter
      ) {
        cost = calculateWinter(categoryValue, mainCost, propertyValue, days);
        found = true;
      } else if (
        dateFrom >= holdSeason[previous].from.winter &&
        dateFrom <= holdSeason[year].to.winter &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter
      ) {
        cost = calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.winter, dateFrom) + 1);
        cost += calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[year].from.winter) + 1);
        cost += calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.summer, holdSeason[year].from.summer) + 1);
        found = true;
      } else if (
        dateFrom >= holdSeason[previous].from.winter &&
        dateFrom <= holdSeason[year].to.winter &&
        dateTo >= holdSeason[year].from.summer &&
        dateTo <= holdSeason[year].to.summer
      ) {
        cost = calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.winter, dateFrom) + 1);
        cost += calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[year].from.summer) + 1);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.summer &&
        dateFrom <= holdSeason[year].to.summer &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter
      ) {
        cost = calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.summer, dateFrom) + 1);
        cost += calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[year].from.winter) + 1);
        found = true;
      }
    } else if (dateFrom.getUTCFullYear() <= dateTo.getUTCFullYear()) {
      if (
        dateFrom >= holdSeason[previous].from.winter &&
        dateFrom <= holdSeason[year].to.winter &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter
      ) {cost = calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.winter, dateFrom) + 1);
        cost += calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[year].from.winter) + 1);
        cost += calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.summer, holdSeason[year].from.summer) + 1);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.winter &&
        dateFrom <= holdSeason[next].to.winter &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter
        ) {
        cost = calculateWinter(categoryValue, mainCost, propertyValue, days);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.winter &&
        dateFrom <= holdSeason[next].to.winter &&
        dateTo >= holdSeason[next].from.summer &&
        dateTo <= holdSeason[next].to.summer
        ) {cost = calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(holdSeason[next].to.winter, dateFrom) + 1);
        cost += calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[next].from.summer) + 1);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.summer &&
        dateFrom <= holdSeason[year].to.summer &&
        dateTo >= holdSeason[next].from.summer &&
        dateTo <= holdSeason[next].to.summer
      ) {
        cost = calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.summer, dateFrom) + 1);
        cost += calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[next].from.summer) + 1);
        cost += calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(holdSeason[next].to.winter, holdSeason[year].from.winter) + 1);
        found = true;
      } else if (
        dateFrom >= holdSeason[year].from.summer &&
        dateFrom <= holdSeason[year].to.summer &&
        dateTo >= holdSeason[year].from.winter &&
        dateTo <= holdSeason[next].to.winter
      ) {
        cost = calculateSummer(mainCost, propertyValue, getDaysFromDateDifference(holdSeason[year].to.summer, dateFrom) + 1);
        cost += calculateWinter(categoryValue, mainCost, propertyValue, getDaysFromDateDifference(dateTo, holdSeason[next].to.winter) + 1);
        found = true;
      }
    }
  });

  cost = mainCalc(categoryValue, cost, mainCost, vesselLengthValue, tempRentValue, isRegisteredCitizenValue, calcElectricityValue, days);
}

function displayCost() {
  document.getElementById('MAIN_COST').innerText = RETURN_CALC_COST.MAIN_COST.toFixed(2);
  document.getElementById('DISCOUNT_FOR_BUSINESS_USE').innerText = RETURN_CALC_COST.DISCOUNT_FOR_BUSINESS_USE.toFixed(2);
  document.getElementById('DISCOUNT_FOR_RELAXATION_BUSINESS_USE').innerText = RETURN_CALC_COST.DISCOUNT_FOR_RELAXATION_BUSINESS_USE.toFixed(2);
  document.getElementById('DISCOUNT_FOR_REGISTERED_CITIZEN').innerText = RETURN_CALC_COST.DISCOUNT_FOR_REGISTERED_CITIZEN.toFixed(2);
  document.getElementById('DISCOUNT_FOR_PRIVATE_USE').innerText = RETURN_CALC_COST.DISCOUNT_FOR_PRIVATE_USE.toFixed(2);
  document.getElementById('INCREASE_FOR_TEMP_RENT').innerText = RETURN_CALC_COST.INCREASE_FOR_TEMP_RENT.toFixed(2);
  document.getElementById('CLEANING_SERVICE').innerText = RETURN_CALC_COST.CLEANING_SERVICE.toFixed(2);
  document.getElementById('WATER_SERVICE').innerText = RETURN_CALC_COST.WATER_SERVICE.toFixed(2);
  document.getElementById('ELECTRICITY_SERVICE').innerText = RETURN_CALC_COST.ELECTRICITY_SERVICE.toFixed(2);
  document.getElementById('DAYS_WINTER').innerText = RETURN_CALC_COST.DAYS_WINTER;
  document.getElementById('DAYS_SUMMER').innerText = RETURN_CALC_COST.DAYS_SUMMER;
  document.getElementById('MAIN_COST_WITH_DIS_INC').innerText = (RETURN_CALC_COST.MAIN_COST -
                                                                RETURN_CALC_COST.DISCOUNT_FOR_BUSINESS_USE -
                                                                RETURN_CALC_COST.DISCOUNT_FOR_RELAXATION_BUSINESS_USE -
                                                                RETURN_CALC_COST.DISCOUNT_FOR_REGISTERED_CITIZEN -
                                                                RETURN_CALC_COST.DISCOUNT_FOR_PRIVATE_USE +
                                                                RETURN_CALC_COST.INCREASE_FOR_TEMP_RENT).toFixed(2);

  showTotal.innerText = RETURN_CALC_COST.TOTAL_COST.toFixed(2);
}

function calcForm() {
  if (
    (typeof category == 'undefined' || category === null || category.value === '') ||
    (typeof from == 'undefined' || from === null || from.val() === '') ||
    (typeof to == 'undefined' || to === null || to.val() === '') ||
    (typeof vesselLength == 'undefined' || vesselLength === null || !Number.isInteger(parseInt(vesselLength.value)) || parseInt(vesselLength.value) < 3) ||
    (typeof tempRent == 'undefined' || tempRent === null || tempRent.value === '') ||
    (typeof property == 'undefined' || property === null || property.value === '') ||
    (typeof isRegisteredCitizen == 'undefined' || isRegisteredCitizen === null || isRegisteredCitizen.value === '') ||
    (typeof calcElectricity == 'undefined' || calcElectricity === null || calcElectricity.value === '')
  ) {
    $.gritter.add({
      title: 'Σφαλμα',
      text: 'προέκυψε σφάλμα στα δεδομένα',
      class_name: 'with-icon times-circle danger'
    });

    resetRETURN_CALC_COST();
    displayCost();
    return 0;
  }
  resetRETURN_CALC_COST();
  
  let categoryValue = category.value;
  let dateFrom = convertDate(from.val(), true);
  let dateTo = convertDate(to.val(), false);
  let vesselLengthValue = Math.floor(parseFloat(vesselLength.value));
  vesselLength.value = vesselLengthValue;
  let tempRentValue = (tempRent.value === 'true');
  let propertyValue = property.value;
  let isRegisteredCitizenValue = (isRegisteredCitizen.value === 'true');
  let calcElectricityValue = calcElectricity.checked;
  
  let diff = getDaysFromDateDifference(dateTo, dateFrom) + 1;
  
  // if ((daysInLeapYear(dateFrom.getFullYear) == 365 && diff > 365) ||
  //     (daysInLeapYear(dateFrom.getFullYear) == 366 && dateFrom <= new Date(`${dateFrom.getFullYear}-02-29`) && dateTo >= new Date(`${dateFrom.getFullYear}-02-29`) && diff > 366)) {
  //   $.gritter.add({
  //     title: 'Σφαλμα',
  //     text: `μέγιστος υπολογισμός: ένα ημερολογιακό έτος`,
  //     class_name: 'with-icon times-circle danger'
  //   });

  //   resetRETURN_CALC_COST();
  //   displayCost();
  //   return 0;
  // }

  if (typeof holdSeason[CURRENT_YEAR] == 'undefined' || typeof holdSeason[CURRENT_YEAR] == 'undefined') {
    generateSeason();
  }
  
  returnCostFromDate(dateFrom, dateTo, categoryValue, vesselLengthValue, tempRentValue, isRegisteredCitizenValue, calcElectricityValue, propertyValue, diff);
  console.log(RETURN_CALC_COST);
  
  displayCost();
}


let holdSeason = {};
const showTotal = document.getElementById('showTotal');
let category = document.getElementById('category');
let vesselLength = document.getElementById('vesselLength');
let tempRent = document.getElementById('tempRent');
let property = document.getElementById('property');
let isRegisteredCitizen = document.getElementById('isRegisteredCitizen');
let calcElectricity = document.getElementById('calcElectricity');
const submitBtn = document.getElementById('submitBtn');
submitBtn.addEventListener('click', calcForm);

generateSeason();