data class ScheduleCell(val info: ScheduleInfo, val categoryGroups: List<RecyclerItem>)

data class ScheduleDate(val dayOfMonth: Int, val dayOfWeek: String, val month: String)

data class ScheduleInfo(val discipline: String, val venue: String)

data class ScheduleCategoryGroup(val category: CompetitionCategory?, val program: CompetitionProgram?)

data class ScheduleCompetitionTime(val minStartTime: Long, val maxEndTime: Long)

fun Schedule.toScheduleInfo() = ScheduleInfo(discipline!!.name, venue!!.name)

fun Schedule.toScheduleCategoryGroup() = ScheduleCategoryGroup(category, program)

fun List<Schedule>.toScheduleCompetitionTime(): ScheduleCompetitionTime {
    var minStartTime = Long.MAX_VALUE
    var maxEndTime = 0L
    forEach { schedule ->
        if (minStartTime > schedule.startTime) minStartTime = schedule.startTime
        if (maxEndTime < schedule.finishTime) maxEndTime = schedule.finishTime
    }
    return ScheduleCompetitionTime(minStartTime, maxEndTime)
}

fun List<Schedule>.toGroupedDisciplines(): Map<ScheduleInfo, Map<ScheduleDate, List<Schedule>>> {
    val sports = asSequence()
            .filter { filter -> filter.name.isEmpty() && filter.discipline != null }
            .sortedWith(compareBy { it.discipline!!.name })
            .groupBy { group -> group.toScheduleInfo() }

    val groupedDiscipline =
            mutableMapOf<ScheduleInfo, Map<ScheduleDate, List<Schedule>>>()
    sports.forEach { sport ->
        groupedDiscipline[sport.key] = sport.value.groupBy {
            it.startTime.toScheduleDate()
        }
    }
    return groupedDiscipline
}

fun Map<ScheduleInfo, Map<ScheduleDate, List<Schedule>>>.toScheduleCells() =
        map {
    ScheduleCell(it.key, it.value.toGroupedCategoryItems())
}

fun Map<ScheduleDate, List<Schedule>>.toGroupedCategoryItems(): List<RecyclerItem> {
    val items = mutableListOf<RecyclerItem>()

    forEach { map ->
        items.add(ScheduleDateItem(map.key))
        val groupMap =
                map.value.asSequence()
                        .sortedWith(compareBy { it.startTime })
                        .groupBy { it.toScheduleCategoryGroup() }
        groupMap.forEach { group ->
            val category = group.key
            if (category.category != null && category.program != null) {
                val value = group.value
                items.add(ScheduleCategoryWithProgramItem(
                        ScheduleDisciplineItem.ScheduleCategoryType.HEADER,
                        value[0],
                        value.toScheduleCompetitionTime()))
                items.addAll(
                        ScheduleCategoryWithProgramItem.generateItem(
                                ScheduleDisciplineItem.ScheduleCategoryType.ROW,
                                value))
            } else {
                items.addAll(ScheduleCategoryItem.generateItems(group.value))
            }
        }
    }

    return items
}