package jointexpense

import (
	"encoding/csv"
	"net/http"
	"nos-comptes/handler"
	"nos-comptes/internal/jointaccount"
	"nos-comptes/internal/storage/dao/postgresql"
	"nos-comptes/internal/storage/model"
	"nos-comptes/internal/storage/validators"
	"nos-comptes/internal/utils"
	"time"

	"github.com/gin-gonic/gin"
)

type Context struct {
	service             *Service
	db                  *Database
	jointaccountService *jointaccount.Service
	*handler.Context
}

func (c *Context) ImportJointexpenseFromCSV(gc *gin.Context) {
}
func (c *Context) CreateAnJointexpense(gc *gin.Context) {
	jointaccountID := gc.Param("jointaccountId")
	userId := gc.Param("userId")
	csvHeaderFile, err := gc.FormFile("attachment")
	if err != nil {
		utils.GetLogger().Info(err)
		utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
		return
	}
	if err == nil {
		csvFile, err := csvHeaderFile.Open()
		if err != nil {
			utils.GetLogger().Info(err)
			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
			return
		}
		csvr := csv.NewReader(csvFile)
		csvr.FieldsPerRecord = -1
		csvr.Comma = ';'
		filedata, err := csvr.ReadAll()

		jointaccount, err := c.jointaccountService.GetASpecificJointaccountForUser(userId, jointaccountID)
		if err != nil {
			utils.GetLogger().Info(err)
			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
			return
		}
		err = c.service.ProcessCSVFile(filedata, jointaccount)
		if err != nil {
			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
			return
		}
		return
	}
	var jointexpense Jointexpense
	var jointexpenseEditable JointexpenseEditable
	if err := gc.BindJSON(&jointexpenseEditable); err != nil {
		utils.JSONError(gc.Writer, validators.NewDataValidationAPIError(err))
		return
	}
	jointexpense = Jointexpense{JointexpenseEditable: jointexpenseEditable, JointaccountId: jointaccountID}
	err = c.service.CreateJointexpense(&jointexpense)
	if err != nil {
		utils.GetLogger().Info(err)
		utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
		return
	}
	utils.JSON(gc.Writer, http.StatusCreated, jointexpense)
}

func (c *Context) DeleteJointexpense(gc *gin.Context) {

}

func (c *Context) GetAllJointexpenses(gc *gin.Context) {
	jointaccountId := gc.Param("jointaccountId")
	from := gc.Query("from")
	to := gc.Query("to")
	var jointexpenses []*Jointexpense
	var err error
	if from != "" || to != "" {
		if to == "" {
			fromParsed, err := time.Parse("2006-01-02", from)
			if err == nil {
				to = time.Now().Format("2006-01-02")
			} else {
				to = fromParsed.AddDate(0, 1, 0).Format("2006-01-02")
			}
		}
		if from == "" {
			toParsed, err := time.Parse("2006-01-02", to)
			if err == nil {
				from = "1900-01-01"
			} else {
				from = toParsed.AddDate(0, -1, 0).Format("2006-01-02")
			}
		}
		jointexpenses, err = c.service.GetJointexpensesOfAnJointaccountBetween(jointaccountId, from, to)
	} else {
		jointexpenses, err = c.service.GetAllJointexpensesOfAnJointaccount(jointaccountId)
	}
	if e, ok := err.(*model.APIError); ok {
		utils.GetLoggerFromCtx(gc).WithError(err).WithField("type", e.Type).Error("error GetAllJointexpenses: get jointexpenses")
		utils.JSONErrorWithMessage(gc.Writer, *e, e.Description)
	} else if err != nil {
		utils.GetLoggerFromCtx(gc).WithError(err).Error("error while get jointexpenses")
		utils.JSONError(gc.Writer, model.ErrInternalServer)
		return
	}

	if len(jointexpenses) == 0 {
		utils.JSON(gc.Writer, http.StatusNoContent, nil)
	} else {
		utils.JSON(gc.Writer, http.StatusOK, jointexpenses)
	}
}

func (c *Context) GetAnJointexpenses(context *gin.Context) {

}

func NewHandler(ctx *handler.Context, db *postgresql.DatabasePostgreSQL) *Context {
	database := NewDatabase(db)
	service := NewService(database)
	jointaccountService := jointaccount.NewService(jointaccount.NewDatabase(db))
	return &Context{service: service, db: database, jointaccountService: jointaccountService, Context: ctx}
}