package ical

import (
	"bytes"
	"encoding/json"
	"github.com/jordic/goics"
	"github.com/labstack/echo/v5"
	"github.com/pocketbase/pocketbase"
	"github.com/pocketbase/pocketbase/apis"
	model "htwk-planner/model"
	db "htwk-planner/service/db"
	"io"
	"net/http"
	"time"
)

const expirationTime = 5 * time.Minute

func Feed(c echo.Context, app *pocketbase.PocketBase, token string) error {
	layout := "2006-01-02 15:04:05 -0700 MST"

	var result string
	var responseWriter = c.Response().Writer
	feed, err := db.FindFeedByToken(token, app)
	if feed == nil && err != nil {
		return c.JSON(http.StatusNotFound, err)
	}

	created, _ := time.Parse(layout, feed.Created)

	var modules []struct {
		Name   string `db:"Name" json:"Name"`
		Course string `db:"course" json:"Course"`
	}
	_ = json.Unmarshal([]byte(feed.Modules), &modules)
	if created.Add(time.Hour * 265).Before(time.Now()) {
		newFeed, err := createFeedForToken(app, modules)
		if err != nil {
			return c.JSON(http.StatusInternalServerError, err)
		}
		result = newFeed.Content
	}

	responseWriter.Header().Set("Content-type", "text/calendar")
	responseWriter.Header().Set("charset", "utf-8")
	responseWriter.Header().Set("Content-Disposition", "inline")
	responseWriter.Header().Set("filename", "calendar.ics")
	writeSuccess(result, responseWriter)
	c.Response().Writer = responseWriter
	return nil
}

func createFeedForToken(app *pocketbase.PocketBase, modules []struct {
	Name   string `db:"Name" json:"Name"`
	Course string `db:"course" json:"Course"`
}) (*model.FeedModel, error) {
	res := db.GetPlanForModules(app, modules)
	b := bytes.Buffer{}
	goics.NewICalEncode(&b).Encode(res)
	feed := &model.FeedModel{Content: b.String(), ExpiresAt: time.Now().Add(expirationTime)}
	return feed, nil
}

func writeSuccess(message string, w http.ResponseWriter) {
	w.WriteHeader(http.StatusOK)
	w.Write([]byte(message))
}

func CreateIndividualFeed(c echo.Context, app *pocketbase.PocketBase) error {

	// read json from request body
	var modules []struct {
		Name   string `db:"Name" json:"Name"`
		Course string `db:"course" json:"Course"`
	}

	requestBodyBytes, err := io.ReadAll(c.Request().Body)
	if err != nil {
		return apis.NewApiError(400, "Could not bind request body", err)
	}

	err = json.Unmarshal(requestBodyBytes, &modules)
	if err != nil {
		return apis.NewApiError(400, "Could not bind request body", err)
	}

	var feed model.Feed
	jsonModules, _ := json.Marshal(modules)
	feed.Modules = string(jsonModules)

	collection, dbError := db.FindCollection(app, "feeds")
	if dbError != nil {
		return apis.NewNotFoundError("Collection not found", dbError)
	}

	record, err := db.SaveFeed(feed, collection, app)
	if err != nil {
		return apis.NewNotFoundError("Feed could not be saved", dbError)
	}

	return c.JSON(http.StatusOK, record.Id)
}