package mapping

import (
	"encoding/json"
	"log"
	"time"

	"gorm.io/datatypes"

	api "github.com/moustachioed/dash/backend/dashapi"
	db "github.com/moustachioed/dash/backend/database/models"
)

type MapperImpl struct{}

func NewMapperImpl() Mapper {
	return MapperImpl{}
}

func (mapper MapperImpl) JournalApiToDs(am interface{}) interface{} {
	apimodel := am.(api.JournalEntry)
	date, err := mapper.StringToDate(apimodel.Date)
	if err != nil {
		log.Printf("[ERROR] Could not parse date `%s`", apimodel.Date)
	}

	thankful, err := json.Marshal(apimodel.Thankful)
	if err != nil {
		thankful = nil
	}

	lookingForward, err := json.Marshal(apimodel.LookingForward)
	if err != nil {
		lookingForward = nil
	}

	beenGreat, err := json.Marshal(apimodel.BeenGreat)
	if err != nil {
		beenGreat = nil
	}

	doBetter, err := json.Marshal(apimodel.DoBetter)
	if err != nil {
		doBetter = nil
	}

	return db.Journal{
		Date:           datatypes.Date(date),
		Thankful:       datatypes.JSON(thankful),
		LookingForward: datatypes.JSON(lookingForward),
		BeenGreat:      datatypes.JSON(beenGreat),
		DoBetter:       datatypes.JSON(doBetter),
		Journal:        apimodel.Journal,
	}
}

func (mapper MapperImpl) JournalDsToApi(dm interface{}) interface{} {
	dbmodel := dm.(db.Journal)

	dateValue, err := dbmodel.Date.Value()
	var date string
	if err != nil {
		date = ""
	} else {
		// date = dateValue.(time.Time).Format("2006-01-02")
		date = mapper.DateToString(dateValue.(time.Time))
	}

	var thankful []string
	err = json.Unmarshal(dbmodel.Thankful, &thankful)
	if err != nil {
		thankful = nil
	}

	var lookingForward []string
	err = json.Unmarshal(dbmodel.LookingForward, &lookingForward)
	if err != nil {
		lookingForward = nil
	}

	var beenGreat []string
	err = json.Unmarshal(dbmodel.BeenGreat, &beenGreat)
	if err != nil {
		beenGreat = nil
	}

	var doBetter []string
	err = json.Unmarshal(dbmodel.DoBetter, &doBetter)
	if err != nil {
		doBetter = nil
	}

	return api.JournalEntry{
		Date:           date,
		Thankful:       thankful,
		LookingForward: lookingForward,
		BeenGreat:      beenGreat,
		DoBetter:       doBetter,
		Journal:        dbmodel.Journal,
	}
}

func (mapper MapperImpl) PlanDayApiToDs(am interface{}) interface{} {
	apimodel := am.(api.PlanDay)
	date, err := mapper.StringToDate(apimodel.Date)
	if err != nil {
		log.Printf("[ERROR] Could not parse date `%s`", apimodel.Date)
	}

	morning, err := json.Marshal(apimodel.Morning)
	if err != nil {
		morning = nil
	}

	midday, err := json.Marshal(apimodel.Midday)
	if err != nil {
		midday = nil
	}

	afternoon, err := json.Marshal(apimodel.Afternoon)
	if err != nil {
		afternoon = nil
	}

	evening, err := json.Marshal(apimodel.Evening)
	if err != nil {
		evening = nil
	}

	pleasant, err := json.Marshal(apimodel.Pleasant)
	if err != nil {
		pleasant = nil
	}

	reminders, err := json.Marshal(apimodel.Reminders)
	if err != nil {
		reminders = nil
	}

	return db.PlanDay{
		Date:      datatypes.Date(date),
		Morning:   datatypes.JSON(morning),
		Midday:    datatypes.JSON(midday),
		Afternoon: datatypes.JSON(afternoon),
		Evening:   datatypes.JSON(evening),
		Pleasant:  datatypes.JSON(pleasant),
		Reminders: datatypes.JSON(reminders),
	}
}

func (mapper MapperImpl) PlanDayDsToApi(dm interface{}) interface{} {
	dbmodel := dm.(db.PlanDay)

	dateValue, err := dbmodel.Date.Value()
	var date string
	if err != nil {
		date = ""
	} else {
		date = mapper.DateToString(dateValue.(time.Time))
	}

	var morning []string
	err = json.Unmarshal(dbmodel.Morning, &morning)
	if err != nil {
		morning = nil
	}

	var midday []string
	err = json.Unmarshal(dbmodel.Midday, &midday)
	if err != nil {
		midday = nil
	}

	var afternoon []string
	err = json.Unmarshal(dbmodel.Afternoon, &afternoon)
	if err != nil {
		afternoon = nil
	}

	var evening []string
	err = json.Unmarshal(dbmodel.Evening, &evening)
	if err != nil {
		evening = nil
	}

	var pleasant []string
	err = json.Unmarshal(dbmodel.Pleasant, &pleasant)
	if err != nil {
		pleasant = nil
	}

	var reminders []string
	err = json.Unmarshal(dbmodel.Reminders, &reminders)
	if err != nil {
		reminders = nil
	}

	return api.PlanDay{
		Date:      date,
		Morning:   morning,
		Midday:    midday,
		Afternoon: afternoon,
		Evening:   evening,
		Pleasant:  pleasant,
		Reminders: reminders,
	}
}

func (mapper MapperImpl) PlanWeekApiToDs(api interface{}) (db interface{}) {
	return new(interface{})
}

func (mapper MapperImpl) PlanWeekDsToApi(api interface{}) (db interface{}) {
	return new(interface{})
}

func (mapper MapperImpl) PlanMonthApiToDs(api interface{}) (db interface{}) {
	return new(interface{})
}

func (mapper MapperImpl) PlanMonthDsToApi(api interface{}) (db interface{}) {
	return new(interface{})
}

func (mapper MapperImpl) StringToDate(dateString string) (time.Time, error) {
	date, err := time.Parse("2006-01-02", dateString)
	if err != nil {
		log.Printf("[ERROR] Could not parse date string %s", dateString)
		return time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC), err
	}
	return date, nil
}

func (mapper MapperImpl) DateToString(date time.Time) string {
	return date.Format("2006-01-02")
}