package v3

import (
	"github.com/pocketbase/pocketbase"
	"github.com/pocketbase/pocketbase/tools/types"
	"golang.org/x/net/http2"
	"htwkalender/model"
	"log/slog"
	"net/http"
	"strconv"
)

func FetchAllResources(app *pocketbase.PocketBase) (*[]model.Event, error) {
	client := &http.Client{}
	client.Transport = &http2.Transport{}

	apiUrl := "https://luna.htwk-leipzig.de/api/"

	seminarUrl := apiUrl + "studierendengruppen"

	parsedSeminarGroups, err := parseSeminarGroups(seminarUrl, client)
	if err != nil {
		slog.Error("Error while fetching seminar groups", err)
		return nil, err
	}
	slog.Info("Fetched seminar groups: " + strconv.Itoa(len(parsedSeminarGroups.Groups)) + " of " + strconv.Itoa(parsedSeminarGroups.TotalItems))

	studyTypeUrl := apiUrl + "studiengaenge"

	parsedStudyTypes, err := parseStudyTypes(studyTypeUrl, client)
	if err != nil {
		slog.Error("Error while fetching study types", err)
		return nil, err
	}
	slog.Info("Fetched study types: " + strconv.Itoa(len(parsedStudyTypes)))

	facultyUrl := apiUrl + "fakultaeten"
	parsedFaculties, err := parseFaculties(facultyUrl, client)
	if err != nil {
		slog.Error("Error while fetching faculties", err)
		return nil, err
	}
	slog.Info("Fetched faculties: " + strconv.Itoa(len(parsedFaculties.Faculties)))

	moduleUrl := apiUrl + "module"
	parsedModules, err := parseModules(moduleUrl, client)
	if err != nil {
		slog.Error("Error while fetching modules", err)
		return nil, err
	}
	slog.Info("Fetched modules: " + strconv.Itoa(len(parsedModules.Modules)))

	roomUrl := apiUrl + "raeume"
	parsedRooms, err := parseRooms(roomUrl, client)
	if err != nil {
		slog.Error("Error while fetching rooms", err)
		return nil, err
	}
	slog.Info("Fetched rooms: " + strconv.Itoa(len(parsedRooms.Rooms)))

	profUrl := apiUrl + "dozierende"
	parsedProfs, err := parseProfs(profUrl, client)
	if err != nil {
		slog.Error("Error while fetching profs", err)
		return nil, err
	}
	slog.Info("Fetched profs: " + strconv.Itoa(len(parsedProfs.Professors)))

	// map seminar groups to model seminar groups
	for _, group := range parsedSeminarGroups.Groups {
		var newGroup model.SeminarGroup
		newGroup.University = "HTWK Leipzig"
		newGroup.Course = group.SeminarGroup
		newGroup.Faculty = group.Faculty
		newGroup.Semester = group.Semester

		// find corresponding study type by studiengang in parsedStudyTypes
		for _, studyTypeItem := range parsedStudyTypes {
			if studyTypeItem.ID == group.Studiengang {
				newGroup.GroupShortcut = studyTypeItem.Description
				newGroup.GroupId = studyTypeItem.GroupID
				break
			}
		}

		for _, facultyItem := range parsedFaculties.Faculties {
			if facultyItem.ID == group.Faculty {
				newGroup.FacultyId = facultyItem.ShortCut
				newGroup.Faculty = facultyItem.Description
				break
			}
		}
	}

	//Now fetch all events
	eventUrl := apiUrl + "veranstaltungen"
	parsedEvents, err := parseEvents(eventUrl, client)
	slog.Info("Fetched events: " + strconv.Itoa(len(parsedEvents.Events)) + " of " + strconv.Itoa(parsedEvents.TotalItems))

	if err != nil {
		slog.Error("Error while fetching events", err)
		return nil, err
	}

	//resolve course id in parsedEvents to course name
	for i, event := range parsedEvents.Events {
		for j, course := range event.Courses {
			for _, group := range parsedStudyTypes {
				if group.ID == course {
					parsedEvents.Events[i].Courses[j] = group.GroupID
				}
			}
		}

		for _, group := range parsedSeminarGroups.Groups {
			for courseItemId, seminarGroupItem := range event.SeminarGroups {
				if group.ID == seminarGroupItem {
					parsedEvents.Events[i].SeminarGroups[courseItemId] = group.SeminarGroup
				}
			}
		}

		for _, facultyItem := range parsedFaculties.Faculties {
			if facultyItem.ID == event.Faculty {
				parsedEvents.Events[i].Faculty = facultyItem.ShortCut
			}
		}

		for _, module := range parsedModules.Modules {
			if module.ID == event.Module {
				parsedEvents.Events[i].Module = module.Name
			}
		}

		for _, room := range parsedRooms.Rooms {
			for roomPlace, roomID := range event.Rooms {
				if room.ID == roomID {
					parsedEvents.Events[i].Rooms[roomPlace] = room.ShortCut
				}
			}
		}

		for _, prof := range parsedProfs.Professors {
			for profPlace, profID := range event.Professors {
				if prof.ID == profID {
					parsedEvents.Events[i].Professors[profPlace] = prof.Description1
				}
			}
		}
	}

	// map events to model events
	var events []model.Event

	for _, event := range parsedEvents.Events {
		for _, week := range event.CalendarWeeks {
			for _, course := range event.Courses {
				var newEvent model.Event
				newEvent.UUID = ""
				newEvent.Day = event.Day
				newEvent.Week = strconv.Itoa(week)
				newEvent.Start, _ = types.ParseDateTime(event.StartTime)
				newEvent.End, _ = types.ParseDateTime(event.EndTime)
				newEvent.Name = event.Module
				newEvent.EventType = event.EventType
				newEvent.Compulsory = ""
				newEvent.Prof = concatStringArray(event.Professors, "|")
				newEvent.Rooms = concatStringArray(event.Rooms, " ")
				newEvent.Notes = event.Description
				newEvent.BookedAt = event.BookedAt
				newEvent.Course = course
				newEvent.Semester = event.Semester
				events = append(events, newEvent)
			}
		}
	}

	// return events
	return &events, nil
}

func concatStringArray(array []string, concatChar string) string {
	var result string

	if len(array) == 0 {
		return result
	}

	if len(array) > 1 {
		for _, item := range array[:len(array)-1] {
			result += item + concatChar
		}
	}
	result += array[len(array)-1]

	return result
}