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) JournalApiToDb(am interface{}) interface{} {
	apimodel := am.(api.JournalEntry)
	date, err := time.Parse("2006-01-02", 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) JournalDbToApi(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")
	}

	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 {
		thankful = nil
	}

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

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

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

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.Now(), err
	}
	return date, nil
}

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