package taxipark

import java.util.*


/*
 * Task #1. Find all the drivers who performed no trips.
 */
fun TaxiPark.findFakeDrivers(): Set<Driver> {

    var driverWithoutTrips = allDrivers.toMutableList()
    var driverWithTrips = ArrayList<Driver>()

    val(trips, noTrips) = trips.partition { it.duration != 0 }
    trips.forEach {
        driverWithTrips.add(it.driver)
    }

    driverWithTrips.forEach {
        if (allDrivers.contains(it))
            driverWithoutTrips.remove(it)
    }

    return driverWithoutTrips.toSet()
}


    /*
     * Task #2. Find all the clients who completed at least the given number of trips.
     */
    fun TaxiPark.findFaithfulPassengers(minTrips: Int): Set<Passenger> {
        var list = mutableSetOf<Passenger>()
        allPassengers.forEach {passenger ->
            var passengerTrips = 0
            trips.forEach { trips ->
                if (trips.passengers.contains(passenger)) {
                    passengerTrips++
                }
            }
            if (minTrips <= passengerTrips) {
                list.add(passenger)
            }
        }
        return list
    }


    /*
     * Task #3. Find all the passengers, who were taken by a given driver more than once.
     */
    fun TaxiPark.findFrequentPassengers(driver: Driver): Set<Passenger> {
        var passengerList = ArrayList<Passenger>()

        trips.forEach {
            if (it.driver.name == driver.name) {
                passengerList.addAll(it.passengers)
            }
        }
        return passengerList.groupingBy { it }.eachCount().filter { it.value > 1 }.keys
    }

    /*
     * Task #4. Find the passengers who had a discount for majority of their trips.
     */
    fun TaxiPark.findSmartPassengers(): Set<Passenger> {
        var count = 0
        var list = allPassengers.associate { Pair(it, 0) }.toMutableMap()

        trips.forEach { trip ->
            trip.passengers.forEach { passenger ->
                count = if (trip.cost < trip.distance + trip.duration) {
                    list[passenger]!!.plus(1)
                } else {
                    list[passenger]!!.minus(1)
                }
                list[passenger] = count
            }
        }

        var result = mutableSetOf<Passenger>()
        list.forEach {
            if (it.value > 0) result.add(it.key)
        }

        return result
    }


    /*
     * Task #5. Find the most frequent trip duration among minute periods 0..9, 10..19, 20..29, and so on.
     * Return any period if many are the most frequent, return `null` if there're no trips.
     */
    fun TaxiPark.findTheMostFrequentTripDurationPeriod(): IntRange? {
        return trips.map {
            it.duration - (it.duration%10)..(it.duration+9 - (it.duration%10))
        }.groupingBy { it }.eachCount().maxBy { it.value }?.key
    }

    /*
     * Task #6.
     * Check whether 20% of the drivers contribute 80% of the income.
     */
    fun TaxiPark.checkParetoPrinciple(): Boolean {
        if (trips.isEmpty()) return false

        var totalCost = 0.0
        var map = allDrivers.associateWith { 0.0 }.toMutableMap()
        trips.forEach {
            totalCost += it.cost
            map[it.driver] = map[it.driver]!!.plus(it.cost)
        }

        val list = map.toList().sortedBy { it.second }
        var twenty: Int = (allDrivers.size * 0.2).toInt()
        var twentyTotalCost = 0.0
        for (i in list.lastIndex downTo (list.lastIndex - twenty + 1)) {
            twentyTotalCost += list[i].second
        }

        return twentyTotalCost >= totalCost * 0.8
    }