const _ = require('lodash')
const moment = require("moment")
const getClimateMinMax = require("./getClimateMinMax.js")
const scorer = require('./score')
const getRegions = require('../models/getRegions.js')

const SHOW_ALL_SCOREOBJECTS = false
const SETTINGS = {
  temperature_mean_max: [4.5, 'easeOut', 2],
  precipitation: [4, 'easeInOut', 2],
  rain_days: [2, 'easeInOut', 2],
  sun_hours: [3.6, 'easeInOut', 2],
  
  accommodation_costs: [17, 'linear', null],
  food_costs: [4, 'linear', null],
  alcohol_costs: [4, 'linear', null],
  water_costs: [10, 'linear', null],
  local_transportation_costs: [5, 'linear', null],
  entertainment_costs: [5, 'easeInOut', 0.6],
  average_per_day_costs: [5, 'linear', null],
  
  avg_price_relative: [3, 'easeOut', 2],
}

module.exports = function (dbConn) {
  return async function (regions, from, to, q) {
    console.log('search')
    if ((_.isNil(to) || _.isNil(from)) && !(_.isEmpty(q.climate) || _.isEmpty(q.costs) || _.isEmpty(q.others))) {
      throw new Error('invalid query')
    }
    // PREPARE SEARCH
    // validate dates
    const dates = validateDates(from, to)
    // for calculating average if traveldates are in more than one month
    const travelPeriods = travelPeriodsFromDates(dates)
    
    
    // FETCH DATA FROM DB
    const boundaryClimate = await getClimateMinMax.getClimateMinMax(dbConn)
    // let regions = await getRegions(dbConn)
    regions.forEach(reg => reg.scores = [])
    const boundaryStatic = {
      max: {
        accommodation_costs: 500,
        food_costs: 100,
        alcohol_costs: 100,
        water_costs: 100,
        local_transportation_costs: 100,
        entertainment_costs: 100,
        average_per_day_costs: 1000,
        avg_price_relative: 100
        
      },
      min: {
        accommodation_costs: 0,
        food_costs: 0,
        alcohol_costs: 0,
        water_costs: 0,
        local_transportation_costs: 0,
        entertainment_costs: 0,
        average_per_day_costs: 0,
        avg_price_relative: 0
      }
    }
    
    // little tweak to show score object without request DEPRECATED
    if (SHOW_ALL_SCOREOBJECTS) {
      if (!q.climate.temperature_mean_max) q.climate.temperature_mean_max = [null, null]
      if (!q.climate.precipitation) q.climate.precipitation = [null, null]
      if (!q.climate.rain_days) q.climate.rain_days = [null, null]
      if (!q.climate.sun_hours) q.climate.sun_hours = [null, null]
      if (!q.climate.accommodation_costs) q.climate.accommodation_costs = [null, null]
    }

    // CALCULATE PROPERTIES FOR EACH REGION
    regions.forEach(reg => {

      // CALCULATE SCORES FOR CLIMATE PROPS
      Object.entries(q.climate).forEach(([key, value]) => {
        let finalScoreObj = calculateScoreForPeriod(key, travelPeriods, reg, value[0], value[1], boundaryClimate)
        reg.scores.push(finalScoreObj)
      });
      
      // CALCULATE SCORES FOR PRICE PROPS
      Object.entries(q.costs).forEach(([key, value]) => {
        let finalScoreObj = calculateSimpleScore(key, reg, value[0], value[1], boundaryStatic)
        
        reg.scores.push(finalScoreObj)
      });
      
      // CALCULATE SCORE FOR OFFSEASON
      if (_.has(q, 'others.avg_price_relative')) {
        let offSeasonScoreObj = calculateScoreForPeriod('avg_price_relative', travelPeriods, reg, q.others.avg_price_relative[0], q.others.avg_price_relative[1], boundaryStatic, 'easeOut', 2)
        reg.scores.push(offSeasonScoreObj)
      }
      
      // CALCULATE PRICE TENDENCY FOR TIMEFRAME
      reg.price_tendency_relative = getAverageFromTrivago(travelPeriods, reg)

      // CALCULATE SUM FOR ACCOMODATION FROM AVERAGE PRICES
      reg.total_accommodation_costs = _.round(sumForRangeAvg(dates.from, dates.to, reg.accommodation_costs), 2)
      //reg.total_avg_lifestyle = _.round(sumForRangeAvg(dates.from, dates.to, reg.average_per_day_costs - reg.accommodation_costs), 2)
      //reg.name = `${reg.name} ca. ${_.round(sumForRangeAvg(dates.from, dates.to, reg.accommodation_costs), 2)}€` 

      // CALCULATE TOTAL PRICE WITH TRANSPORTATION

      // CALCULATE TOTAL PRICE WITH TRANSPORTATION AND ESTEEMED LIFE COSTS
      
      // CALCULATE AVERAGE SCORE Stage 1
      let scoreSubGroups = []
      if (!_.isEmpty(q.climate)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(Object.keys(q.climate), entry => entry === el.type ) )) )
      if (!_.isEmpty(q.costs)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(Object.keys(q.costs), entry => entry === el.type ))) )
      if (!_.isEmpty(q.others)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(Object.keys(q.others), entry => entry === el.type ) )) )
      
      // CALCULATE AVERAGE SCORE Stage 2
      reg.score = calculateAverage(reg.scores) 
      // reg.score = _.sum(scoreSubGroups) / scoreSubGroups.length
    })
    return _.orderBy(regions, ({ score }) => score || 0, 'desc') //.filter(el => !_.isNaN(el.score))
  }

  function sumForRangeAvg(from, to, avg) {
    let duration = moment(to).diff(moment(from), 'days')
    return duration * avg
  }

  function sumForRangeFromDailyValues(from, to, dailyValues) {
    // NOT NEEDED YET
    // for (var m = moment(from).subtract(1, 'months'); m.isSameOrBefore(moment(to).subtract(1, 'months')); m.add(1, 'day')) {
    //   console.log(m);
    // }
  }

  
  function calculateAverage(scores) {
    let sum = 0
    let cnt = 0
    scores.forEach(el => {
      if (el.score !== null && el.score !== undefined && !_.isNaN(el.score)) {
        cnt++
        sum += el.score
      }
      if (el.score === null || el.score === undefined || _.isNaN(el.score)) {
        cnt++
        sum += -1
      }
    })
    //if (sum === 0 && cnt === 0) return 0
    return _.round(sum / cnt, 3)
  }
  
  function travelPeriodsFromDates(dates) {
    let travelPeriods = []

    if (dates.from.month === dates.to.month && dates.from.year === dates.to.year) {
      let period = {
        month: dates.from.month,
        days: dates.to.day - dates.from.day
      }
      travelPeriods.push(period)

    } else {
      for (var m = moment(dates.from).subtract(1, 'months'); m.isSameOrBefore(moment(dates.to).subtract(1, 'months').endOf("month")); m.add(1, 'months')) {
        travelPeriods.push(createPeriod(dates.from, dates.to, m.month() + 1, m.year()))
      }
    }
    return travelPeriods
  }
  
  function validateDates(from, to) {
    let fromAndTo = {
      from: {},
      to: {}
    }

    if (_.isNumber(from) && _.isNumber(to)) {
      let dateFrom = new Date(from)
      fromAndTo.from.day = dateFrom.getDate()
      fromAndTo.from.month = dateFrom.getMonth() + 1
      fromAndTo.from.year = dateFrom.getFullYear()
      let dateTo = new Date(to)
      fromAndTo.to.day = dateTo.getDate()
      fromAndTo.to.month = dateTo.getMonth() + 1
      fromAndTo.to.year = dateFrom.getFullYear()
    } else {
      // this block to still support old query syntax, validating from and to parameter
      let re = /([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))/i;
      fromAndTo.from.year = Number(from.split("-")[0])
      fromAndTo.to.year = Number(to.split("-")[0])
      fromAndTo.from.month = Number(from.split("-")[1])
      fromAndTo.to.month = Number(to.split("-")[1])
      fromAndTo.from.day = Number(from.split("-")[2])
      fromAndTo.to.day = Number(to.split("-")[2])
      if (!from.match(re) || !to.match(re)) throw new Error("ERR: invalid parameter:", from, to)
    }

    if (moment(fromAndTo.from).add(23, 'hours').isAfter(moment(fromAndTo.to))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
    return fromAndTo
  }

  function createPeriod(from, to, currentMonth, currentYear) {
    let period = {}
    if (currentMonth === from.month && currentYear === from.year) {
      period = {
        month: currentMonth,
        days: 32 - from.day
      }
    } else if (currentMonth === to.month) {
      period = {
        month: currentMonth,
        days: to.day
      }
    } else {
      period = {
        month: currentMonth,
        days: 30
      }
    }
    return period
  }

  
  function calculateScoreForPeriod(type, travelPeriods, region, searchLowParam, searchMaxParam, minMax) {
    // console.log('getScoreAndAverageFromClimate for', region.name, type)
    
    const singleScores = travelPeriods.map(period => {
      let res = {
        type: type,
        value: region[type][period.month - 1],
        days: period.days
      }
      
      return res
    })
    
    let averagedScore = {
      type: type,
      value: 0,
      days: 0
    }
    singleScores.forEach(el => {
      if (el.value !== null && !_.isNaN(el.value)) {
        averagedScore.value += (el.value * el.days)
        averagedScore.days += (el.days)
      } else {
        // console.log('skip averaging')
        // console.log(el)
        
      }
    })
    averagedScore.value = _.round(averagedScore.value / averagedScore.days, 3)
    delete averagedScore.days
    
    let sc = scorer.calculateScoreRange(minMax.min[type], minMax.max[type], SETTINGS[type][0], averagedScore.value, searchLowParam, searchMaxParam)    
    averagedScore.score = _.round(scorer[SETTINGS[type][1]](sc, SETTINGS[type][2]), 3)
    // console.log('score', averagedScore.score)
    if (searchLowParam === null) averagedScore.score = null
    
    return averagedScore
  }
  
  function calculateSimpleScore(type, region, searchLowParam, searchMaxParam, minMax) {
    // console.log('getScoreFromCosts for', region.name, type)
    const sc = _.round(scorer.calculateScoreRange(minMax.min[type], minMax.max[type], SETTINGS[type][0], region[type], searchLowParam, searchMaxParam), 3)
    
    let finScore = {
      type: type,
      value: region[type],
      score: scorer[SETTINGS[type][1]](sc, SETTINGS[type][2]),
    }
    finScore.value = _.round(finScore.value, 1)
    finScore.score = _.round(finScore.score, 3)
    if (searchLowParam === null) finScore.score = null
    
    return finScore
  }
  
  function getAverageFromTrivago(travelPeriods, region) {
    // console.log('getAverageFromTrivago for', region.name)
    
    const singleScores = travelPeriods.map(period => {
      let res = {
        value: region.avg_price_relative[period.month - 1],
        days: period.days
      }
      
      return res
    })
    
    let averagedScore = {
      value: 0,
      days: 0
    }
    singleScores.forEach(el => {
      if (el.value !== null && !_.isNaN(el.value)) {
        averagedScore.value += (el.value * el.days)
        averagedScore.days += (el.days)
      } else {
        // console.log('skip averaging')
        // console.log(el)
        
      }
    })
    averagedScore.value = _.round(averagedScore.value / averagedScore.days, 2)
    
    return averagedScore.value
  }
  
  //end
}