package db

import (
	"github.com/pocketbase/dbx"
	"github.com/pocketbase/pocketbase"
	"github.com/pocketbase/pocketbase/models"
	"htwkalender/model"
	"log"
)

func SaveEvents(seminarGroup []model.SeminarGroup, collection *models.Collection, app *pocketbase.PocketBase) ([]*models.Record, error) {
	var toBeSavedEvents []struct {
		model.Event
		string
	}
	var savedRecords []*models.Record
	var insertRecords []*models.Record

	// check if event is already in database and add to toBeSavedEvents if not
	for _, seminarGroup := range seminarGroup {
		for _, event := range seminarGroup.Events {
			dbGroup, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)

			if dbGroup == nil && err.Error() == "sql: no rows in result set" {
				toBeSavedEvents = append(toBeSavedEvents, struct {
					model.Event
					string
				}{event, seminarGroup.Course})
			} else if err != nil {
				return nil, err
			}
		}
	}

	// create record for each event that's not already in the database
	for _, event := range toBeSavedEvents {
		record := models.NewRecord(collection)
		record.Set("Day", event.Day)
		record.Set("Week", event.Week)
		record.Set("Start", event.Start)
		record.Set("End", event.End)
		record.Set("Name", event.Name)
		record.Set("EventType", event.EventType)
		record.Set("Prof", event.Prof)
		record.Set("Rooms", event.Rooms)
		record.Set("Notes", event.Notes)
		record.Set("BookedAt", event.BookedAt)
		record.Set("course", event.string)
		record.Set("semester", event.Semester)
		insertRecords = append(insertRecords, record)
	}

	// save all records
	for _, record := range insertRecords {
		if record != nil {
			err := app.Dao().SaveRecord(record)
			if err == nil {
				savedRecords = append(savedRecords, record)
			} else {
				log.Println("Error while saving record: ", err)
				return nil, err
			}
		}
	}

	return savedRecords, nil
}

func findEventByDayWeekStartEndNameCourse(event model.Event, course string, app *pocketbase.PocketBase) (*model.Event, error) {
	err := app.Dao().DB().Select("*").From("events").Where(
		dbx.NewExp("Day = {:day} AND Week = {:week} AND Start = {:start} AND End = {:end} AND Name = {:name} AND course = {:course} AND Prof = {:prof} AND Rooms = {:rooms} AND EventType = {:eventType}",
			dbx.Params{"day": event.Day, "week": event.Week, "start": event.Start, "end": event.End, "name": event.Name, "course": course, "prof": event.Prof, "rooms": event.Rooms, "eventType": event.EventType}),
	).One(&event)
	if err != nil {
		return nil, err
	}
	return &event, err
}

func GetPlanForModules(app *pocketbase.PocketBase, modules []model.FeedCollection) model.Events {

	// build query functions with name equals elements in modules for dbx query

	var queryString string
	for i, module := range modules {
		if i == 0 {
			queryString = "Name = '" + module.Name + "' AND course = '" + module.Course + "'"
		} else {
			queryString = queryString + " OR Name = '" + module.Name + "' AND course = '" + module.Course + "'"
		}
	}

	var events model.Events
	// get all events from event records in the events collection
	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp(queryString)).All(&events)
	if err != nil {
		print("Error while getting events from database: ", err)
		return nil
	}
	return events
}

func GetAllModulesForCourse(app *pocketbase.PocketBase, course string, semester string) ([]string, error) {
	var events []struct {
		Name string `db:"Name" json:"Name"`
	}

	var eventArray []string

	// get all events from event records in the events collection
	err := app.Dao().DB().Select("Name").From("events").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Distinct(true).All(&events)
	if err != nil {
		print("Error while getting events from database: ", err)
		return eventArray, err
	}

	for _, event := range events {
		eventArray = append(eventArray, event.Name)
	}
	return eventArray, nil
}

func GetAllModulesDistinct(app *pocketbase.PocketBase) ([]struct {
	Name   string
	Course string
}, error) {
	var events []struct {
		Name   string `db:"Name" json:"Name"`
		Course string `db:"course" json:"course"`
	}

	var eventArray []struct {
		Name   string
		Course string
	}

	err := app.Dao().DB().Select("Name", "course").From("events").Distinct(true).All(&events)
	if err != nil {
		print("Error while getting events from database: ", err)
		return eventArray, err
	}

	for _, event := range events {
		eventArray = append(eventArray, struct {
			Name   string
			Course string
		}{event.Name, event.Course})
	}
	return eventArray, nil
}