package logging

import (
	"context"
	"time"

	cml04eventer "git.espin.casa/albert/cml04-eventer"
	"git.espin.casa/albert/cml04-mediciones-service/internal/service"
	"git.espin.casa/albert/cml04-mediciones-service/internal/types"
	"git.espin.casa/albert/logger"
)

type LoggingService struct {
	log  logger.LoggerAdapter
	next service.IService
}

// GetExcel implements service.IService.
func (svc *LoggingService) GetExcel(ctx context.Context, req types.GetExcelReq) (res types.GetExcelRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("create excel failed", err, logFields)
		} else {
			svc.log.Info("create excel success", logFields)
		}
	}(time.Now())
	return svc.next.GetExcel(ctx, req)
}

// ValidarUsuario implements service.IService.
func (svc *LoggingService) ValidarUsuario(ctx context.Context, req types.ValidarUsuarioReq) (res types.ValidarUsuarioRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("validate user failed", err, logFields)
		} else {
			svc.log.Info("validate user success", logFields)
		}
	}(time.Now())
	return svc.next.ValidarUsuario(ctx, req)
}

// CreateUsuario implements service.IService.
func (svc *LoggingService) CreateUsuario(ctx context.Context, req types.CreateUsuarioReq) (res types.CreateUsuarioRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("create usuario failed", err, logFields)
		} else {
			svc.log.Info("create usuario success", logFields)
		}
	}(time.Now())
	return svc.next.CreateUsuario(ctx, req)
}

// GetUsuario implements service.IService.
func (svc *LoggingService) GetUsuario(ctx context.Context, req types.GetUsuarioReq) (res types.GetUsuarioRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("get medicion failed", err, logFields)
		} else {
			svc.log.Info("get medicion success", logFields)
		}
	}(time.Now())
	return svc.next.GetUsuario(ctx, req)
}

// GetMedicion implements service.IService.
func (svc *LoggingService) GetMedicion(ctx context.Context, req types.GetMedicionReq) (res types.GetMedicionRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("get medicion failed", err, logFields)
		} else {
			svc.log.Info("get medicion success", logFields)
		}
	}(time.Now())
	return svc.next.GetMedicion(ctx, req)
}

// GetMediciones implements service.IService.
func (svc *LoggingService) GetMediciones(ctx context.Context, req types.GetMedicionesReq) (res types.GetMedicionesRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("get mediciones failed", err, logFields)
		} else {
			svc.log.Info("get mediciones success", logFields)
		}
	}(time.Now())
	return svc.next.GetMediciones(ctx, req)
}

// PostMediciones implements service.IService.
func (svc *LoggingService) PostMediciones(ctx context.Context, req types.PostMedicionesReq) (res types.PostMedicionesRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("post mediciones failed", err, logFields)
		} else {
			svc.log.Info("post mediciones success", logFields)
		}
	}(time.Now())
	return svc.next.PostMediciones(ctx, req)
}

// GetProductionOrders implements service.IService.
func (svc *LoggingService) GetProductionOrders(ctx context.Context, req types.GetProductionOrdersReq) (res types.GetProductionOrdersRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("get production order data failed", err, logFields)
		} else {
			svc.log.Info("get production order data success", logFields)
		}
	}(time.Now())
	return svc.next.GetProductionOrders(ctx, req)
}

// GetProductionOrder implements service.IService.
func (svc *LoggingService) GetProductionOrder(ctx context.Context, req types.GetProductionOrderReq) (res types.GetProductionOrderRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("get production orders data failed", err, logFields)
		} else {
			svc.log.Info("get production orders data success", logFields)
		}
	}(time.Now())
	return svc.next.GetProductionOrder(ctx, req)
}

// CreateProductionOrder implements service.IService.
func (svc *LoggingService) CreateProductionOrder(ctx context.Context, po *types.OrdenFabricacion) (err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("create production order failed", err, logFields)
		} else {
			svc.log.Info("create production order success", logFields)
		}
	}(time.Now())
	return svc.next.CreateProductionOrder(ctx, po)
}

// ProcessEvent implements service.IService.
func (svc *LoggingService) ProcessEvent(ctx context.Context, event *cml04eventer.Event) (err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("process event failed", err, logFields)
		} else {
			svc.log.Info("process event success", logFields)
		}
	}(time.Now())
	return svc.next.ProcessEvent(ctx, event)
}

// CreateTolerance implements service.IService.
func (svc *LoggingService) CreateTolerance(ctx context.Context, req types.CreateToleranceReq) (res types.CreateToleranceRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			svc.log.Error("create product tolerance failed", err, logFields)
		} else {
			svc.log.Info("create product tolerance success", logFields)
		}
	}(time.Now())
	return svc.next.CreateTolerance(ctx, req)
}

// GetTolerance implements service.IService.
func (svc *LoggingService) GetTolerance(ctx context.Context, req types.GetToleranciaReq) (res types.GetToleranciaRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took":            time.Since(start),
			"product_request": req.Medida,
		}
		if err != nil {
			svc.log.Error("get product tolerance data failed", err, logFields)
		} else {
			svc.log.Info("get product tolerance data success", logFields)
		}
	}(time.Now())
	return svc.next.GetTolerance(ctx, req)
}

func NewLoggingService(log logger.LoggerAdapter, svc service.IService) service.IService {
	return &LoggingService{
		log:  log,
		next: svc,
	}
}