const _ = require('lodash')
const moment = require("moment")
const scorer = require('./score')
const SETTINGS = require('../settings').scoring

module.exports = async function (data, from, to, q) {
  console.log('search')
  console.log(q)
  if ((_.isNil(to) || _.isNil(from)) && !(_.isEmpty(q.climate) || _.isEmpty(q.costs) || _.isEmpty(q.others))) {
    throw new Error('invalid query')
  }
  if (_.isNil(data) || _.isEmpty(data.regions)) {
    throw new Error('database error')
  }
  let regionsArr = data.regions
  // PREPARE SEARCH
  // validate dates
  const dates = validateDates(from, to)
  // for calculating average if traveldates are in more than one month
  const travelPeriods = travelPeriodsFromDates(dates)
    
  // CALCULATE PROPERTIES FOR EACH REGION
  regionsArr.forEach(reg => {

    // CALCULATE SCORES FOR CLIMATE PROPS
    reg.scores = []
    Object.entries(q.climate).forEach(([key, value]) => {
      let finalScoreObj = calculateScoreForPeriod(key, travelPeriods, reg, value[0], value[1])
      reg.scores.push(finalScoreObj)
    });
    
    // CALCULATE SCORES FOR PRICE PROPS
    Object.entries(q.costs).forEach(([key, value]) => {
      let finalScoreObj = scoreFromSimpleRegionProperty(key, reg, value[0], value[1])
      
      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], 'easeOut', 2)
      reg.scores.push(offSeasonScoreObj)
    }

    // CALCULATE SCORE FOR TAGS
    if (_.has(q, 'others.tags')) {
      reg.scores.push(...scoresFromTags(reg.tags, q.others.tags))
    }
    
    // CALCULATE PRICE TENDENCY FOR TIMEFRAME
    reg.price_tendency_relative = getAverageFromTrivago(travelPeriods, reg)
    
    // CALCULATE SUM FOR ACCOMODATION FROM AVERAGE PRICES AND APPROX LIFESTYLE COSTS
    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.avg_price_relative)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => 'avg_price_relative' === el.type ) )) 
    if (!_.isEmpty(q.others.tags)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(q.others.tags, entry => entry === el.type ))) )
    
    // CALCULATE AVERAGE SCORE Stage 2
    // reg.score = calculateAverage(reg.scores) 
    reg.score = _.round(_.sum(scoreSubGroups) / scoreSubGroups.length, 3)

  })
  return _.orderBy(regionsArr, ({ 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 start = moment(`${dates.from.year}-${dates.from.month}-${dates.from.day}`, 'YYYY-MM-DD')
  let end = moment(`${dates.to.year}-${dates.to.month}-${dates.to.day}`, 'YYYY-MM-DD')
  console.log('start:', moment(start));
  console.log('end:', moment(end));
  // console.log('start:', moment(start).toISOString());
  // console.log('end:', moment(end).toISOString());
  //   console.log('start:', moment(dates.from));
  // console.log('end:', moment(dates.to));
  console.log();
  console.log();
  console.log();
  
  
  let travelPeriods = []
  
  if (start.month() === end.month() && start.year() === end.year()) {
    let period = {
      month: start.month()+1,
      days: end.date() - start.date()
    }
    travelPeriods.push(period)
    
  } else {
    for (var m = moment(start); m.isSameOrBefore(moment(end).endOf("month")); m.add(1, 'months')) {
      console.log(m);
      
      travelPeriods.push(createPeriod(start, end, 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 = dateTo.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)
  }
  console.log(moment(`${fromAndTo.from.year}-${fromAndTo.from.month}-${fromAndTo.from.day}`, 'YYYY-MM-DD'))
  console.log(moment(`${fromAndTo.to.year}-${fromAndTo.to.month}-${fromAndTo.to.day}`, 'YYYY-MM-DD'))
  if (moment(`${fromAndTo.from.year}-${fromAndTo.from.month}-${fromAndTo.from.day}`, 'YYYY-MM-DD').add(23, 'hours').isAfter(moment(`${fromAndTo.to.year}-${fromAndTo.to.month}-${fromAndTo.to.day}`, 'YYYY-MM-DD'))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
  return fromAndTo
}

function createPeriod(start, end, currentMonth, currentYear) {
  let period = {}
  console.log(start, end, currentMonth, currentYear);
  
  if (currentMonth === start.month() + 1 && currentYear === start.year()) {
    console.log('first month')
    period = {
      month: currentMonth,
      days: 32 - start.date()
    }
  } else if (currentMonth === end.month() + 1) {
    console.log('end month')
    period = {
      month: currentMonth,
      days: end.date()
    }
  } else {
    console.log('middle month')
    period = {
      month: currentMonth,
      days: 30
    }
  }
  return period
}


function calculateScoreForPeriod(type, travelPeriods, region, searchLowParam, searchMaxParam) {
  // console.log('getScoreAndAverageFromClimate for', region.name, type)
  
  const singleScores = travelPeriods. map(period => {
    let res = {
      type: type,
      value:  region[type] !== null ? region[type][period.month - 1] : null,
      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 transitionRange = SETTINGS[type][0]
  // special for precipitation
  if (type === 'precipitation') {
    transitionRange = scorer.increaseTransitionForHighValues(SETTINGS[type][0], searchLowParam)
  }
  
  let sc = scorer.calculateScoreRange(transitionRange, 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 scoresFromTags(regionTags, tagStringsFromQueries) {
  return tagStringsFromQueries.map(tagQuery => {
    const tag = regionTags.find(tag => tagQuery === tag.name)
    let retVal = {
      type: tagQuery,
      value: null,
      score: null,
    }
    if (_.isNil(tag)) return retVal
    retVal.value = tag.value
    retVal.score = /* tag.value <= 0 ? 0 : */ _.round(scorer.calculateScoreRange(60, tag.value, 100, 100), 3)
    console.log(retVal);
    
    return retVal
  })
}

function scoreFromSimpleRegionProperty(type, region, searchLowParam, searchMaxParam, minMax) {
  // console.log('getScoreFromCosts for', region.name, type)
  const sc = _.round(scorer.calculateScoreRange(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
}