package ex07


trait TUniversity {

    trait TStudent
    type Student <: TStudent

    trait TCourseOfStudies[C <: Course]
    type CourseOfStudies <: TCourseOfStudies[Course]

    trait TRoom
    type Room <: TRoom

    trait TCourse
    type Course <: TCourse

    def courses: Seq[Course]

    def allCourseOfStudies: Seq[CourseOfStudies]

    def students: Seq[Student]

    def rooms: Seq[Room]

    def makeRoomAvailable(room: Room)

    def enrollStudent(student: Student)

    def registerCourse(course: Course)

    def planCourseOfStudies(cos: CourseOfStudies)
}


trait TSimpleUniversity extends TUniversity {
    trait TCourse extends super.TCourse {
        def name: String
        def lecturer: String
        def creditPoints: Int
        def room: Room
    }
//    type Course <: TCourse

    trait TRoom extends super.TRoom {
        def number: String
    }
//    type Room <: TRoom

    trait TCourseOfStudies extends super.TCourseOfStudies[Course] {
        def name: String
        def courses[C <: Course]: Seq[C]
        def degree: String
        def totalCreditPoints: Int
    }
//    type CourseOfStudies <: TCourseOfStudies

    trait TStudent extends super.TStudent {
        def name: String
        def matriculationNumber: String
        def courses: Seq[Course]
        def courseOfStudies: CourseOfStudies
    }
//    type Student <: TStudent
}

class SimpleUniversity extends TSimpleUniversity {
    var Rooms = List.empty[Room]
    var Courses = List.empty[Course]
    var CoursesOfStudies = List.empty[CourseOfStudies]
    var Students = List.empty[Student]

    type Student = TStudent
    type Room = TRoom
    type Course = TCourse
    type CourseOfStudies = TCourseOfStudies

    def Student(str: String, str1: String, cos1: CourseOfStudies): Student = new Student {
        override def name: String = str

        override def matriculationNumber: String = str1

        override def courseOfStudies: CourseOfStudies = cos1

        override def courses: Seq[Course] = Courses
    }

    def CourseOfStudies(str: String, courses: List[Course], str1: String, i: Int): CourseOfStudies = new CourseOfStudies {
        override def name: String = str

        override def courses[C <: Course]: Seq[C] = courses

        override def degree: String = str1

        override def totalCreditPoints: Int = i
    }

    def Course(str: String, str1: String, i: Int, r1: Room): Course = new Course {
        override def name: String = str

        override def lecturer: String = str1

        override def creditPoints: Int = i

        override def room: Room = r1
    }

    def Room(str: String): Room = new Room {
        override def number: String = str
    }

    override def courses: Seq[Course] = {
        Courses
    }

    override def allCourseOfStudies: Seq[CourseOfStudies] = {
        CoursesOfStudies
    }

    override def students: Seq[Student] = {
        Students
    }

    override def rooms: Seq[Room] = {
        Rooms
    }

    override def makeRoomAvailable(room: Room): Unit = {
        Rooms = Rooms :+ room
    }

    override def enrollStudent(student: Student): Unit = {
        Students = Students :+ student
    }

    override def registerCourse(course: Course): Unit = {
        Courses = Courses :+ course
    }

    override def planCourseOfStudies(cos: CourseOfStudies): Unit = {
        CoursesOfStudies = CoursesOfStudies :+ cos
    }

}

trait TComplexUniversity extends TUniversity {
    trait TRoom extends super.TRoom {
        def building: String
    }

    trait TStudent extends super.TStudent {
        def loginId: String
    }

    trait TCourse extends super.TCourse {
        def prerequisites: Seq[Course]
    }

    trait TCourseOfStudies extends super.TCourseOfStudies[Course] {
        def coordinator: String
    }
}

trait TCompositeUniversity extends TSimpleUniversity with TComplexUniversity {
    trait TRoom extends super[TSimpleUniversity].TRoom with super[TComplexUniversity].TRoom{}
    trait TCourse extends super[TSimpleUniversity].TCourse with super[TComplexUniversity].TCourse{}
    trait TStudent extends super[TSimpleUniversity].TStudent with super[TComplexUniversity].TStudent{}
    trait TCourseOfStudies extends super[TSimpleUniversity].TCourseOfStudies with super[TComplexUniversity].TCourseOfStudies{}
}

class ComplexUniversity extends TCompositeUniversity {
    var Rooms = List.empty[Room]
    var Courses = List.empty[Course]
    var CoursesOfStudies = List.empty[CourseOfStudies]
    var Students = List.empty[Student]

    type Student = TStudent
    type Room = TRoom
    type Course = TCourse
    type CourseOfStudies = TCourseOfStudies

    def Student(str: String, loginId: String, str1: String, cos1: CourseOfStudies): Student = new Student{
        def name: String = str

        def matriculationNumber: String = str1

        def courseOfStudies: CourseOfStudies = cos1

        def courses: Seq[Course] = Courses

        def loginId: String = loginId
    }

    def CourseOfStudies(str: String, co: String, courses: List[Course], str1: String, i: Int): CourseOfStudies = new CourseOfStudies {
        def name: String = str

        def courses[C <: Course]: Seq[C] = courses

        def degree: String = str1

        def totalCreditPoints: Int = i

        def coordinator: String = co
    }

    def Course(str: String, str1: String, i: Int, r1: Room, pr: Seq[Course]): Course = new Course {
        def name: String = str

        def lecturer: String = str1

        def creditPoints: Int = i

        def room: Room = r1

        def prerequisites: Seq[Course] = pr
    }

    def Room(str: String, str1: String): Room = new Room {
        def building: String = str1

        def number: String = str
    }

    override def courses: Seq[Course] = {
        Courses
    }

    override def allCourseOfStudies: Seq[CourseOfStudies] = {
        CoursesOfStudies
    }

    override def students: Seq[Student] = {
        Students
    }

    override def rooms: Seq[Room] = {
        Rooms
    }

    override def makeRoomAvailable(room: Room): Unit = {
        Rooms = Rooms :+ room
    }

    override def enrollStudent(student: Student): Unit = {
        Students = Students :+ student
    }

    override def registerCourse(course: Course): Unit = {
        Courses = Courses :+ course
    }

    override def planCourseOfStudies(cos: CourseOfStudies): Unit = {
        CoursesOfStudies = CoursesOfStudies :+ cos
    }
}


object AdministrationTool {

    def printCourseOfStudies[U <: TUniversity](courseOfStudies: Seq[U#CourseOfStudies]): String = courseOfStudies.mkString("\n")

    def getListOfStudents[U <: TUniversity](students: Seq[U#Student]): String = students.mkString("\n")

}

object Main {

    def main(args: Array[String]): Unit = {
        val u1 = simpleUniversity
        val u2 = complexUniversity

        println(AdministrationTool.printCourseOfStudies(u1.allCourseOfStudies))
        println(AdministrationTool.printCourseOfStudies(u2.allCourseOfStudies))
        println(AdministrationTool.getListOfStudents(u1.students))
        println(AdministrationTool.getListOfStudents(u2.students))
    }

    def complexUniversity: TComplexUniversity = {
        val cUni = new ComplexUniversity
        val r1 = cUni.Room("Room1", "Building1")
        val r2 = cUni.Room("Room2", "Building2")
        val c1 = cUni.Course("Course1", "Lecture1", 3, r1, Nil)
        val c2 = cUni.Course("Course2", "Lecture1", 6, r2, c1 :: Nil)
        val cos1 = cUni.CourseOfStudies("cos1", "Coordinator1", List(c1, c2), "degree1", 9)
        val s1 = cUni.Student("Student1", "ab12cdef", "1234", cos1)
        cUni.registerCourse(c1)
        cUni.registerCourse(c2)
        cUni.makeRoomAvailable(r1)
        cUni.planCourseOfStudies(cos1)
        cUni.enrollStudent(s1)
        cUni
    }

    def simpleUniversity: TSimpleUniversity = {
        val sUni = new SimpleUniversity
        val r1 = sUni.Room("Room1")
        val c1 = sUni.Course("Course1", "Lecturer1", 3, r1)
        val c2 = sUni.Course("Course2", "Lecturer1", 6, r1)
        val cos1 = sUni.CourseOfStudies("cos1", List(c1, c2), "degree1", 9)
        val s1 = sUni.Student("Student1", "1234", cos1)
        sUni.registerCourse(c1)
        sUni.registerCourse(c2)
        sUni.makeRoomAvailable(r1)
        sUni.planCourseOfStudies(cos1)
        sUni.enrollStudent(s1)
        sUni
    }
}