package service

import (
	"context"
	"fmt"
	"strconv"

	"time"

	"git.espin.casa/albert/cml04-falcon-system/internal/types"
	"github.com/nats-io/nats.go"
	"github.com/nats-io/nats.go/micro"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

type Service interface {
	Subscribe() error
	Close(ctx context.Context) error
}

const TimeOut time.Duration = time.Second * 2

type DBConfig struct {
	Username string
	Password string
	Host     string
	Port     int
	Name     string
}

type NATSConfig struct {
	Host string
	Port int
}

func Nats(conf *NATSConfig) (*nats.Conn, error) {
	// NATS connect
	nc, err := nats.Connect(fmt.Sprintf("nats://%s:%d", conf.Host, conf.Port))
	if err != nil {
		return nil, err
	}
	return nc, nil
}

type service struct {
	db  *gorm.DB
	nc  *nats.Conn
	srv micro.Service
}

func (s *service) svcNewLabelHandler(req micro.Request) {
	// label holder
	var label types.Label
	// get label identificator
	labelID := string(req.Data())
	if err := s.db.First(&label, labelID).Error; err != nil {
		return
	}
	// convert logo code
	dibujo, err := strconv.Atoi(label.LogoCode)
	if err != nil {
		return
	}

	// bundle data
	bundle := &types.BundleData{
		Grupo6:              "",
		Po:                  int(label.ProductionOrderNo),
		Co:                  int(label.CustomerOrderNo),
		Colada:              label.HeatId,
		Calidad:             label.SteelGrade,
		Matnr:               label.MaterialCode,
		Dibujo:              dibujo,
		Operador:            "AUT", // <--
		Serie:               0,
		Nromatricula:        "", // <--
		NroBulto:            strconv.Itoa(int(label.L2PackageId)),
		EtiquetaDoble:       "S",
		Fecha:               0,
		Turno:               "", // <--
		Observacion1:        "obser.1",
		Observacion2:        "obser.2",
		Observacion3:        "obser.3",
		PaqueteLongitud:     0,
		PaqueteAncho:        0,
		PaqueteAlto:         0,
		PaquetePeso:         0,
		PaqueteNroSecciones: 0,
		PaqueteNroMantos:    0,
		PaqueteNroSeccManto: 0,
		SeccionTipo:         label.SectionType,
		SeccionLongitud:     0,
		SeccionAncho:        0,
		SeccionAlto:         0,
		Idioma:              "ES",
		Destino:             0,
		Hora:                0,
		Horario:             0,
		Inst:                "EST",
		Tren:                1,
		Normed:              "",
		Norpro:              "",
		Nortol:              "",
		Spras:               "",
		Statu:               0,
		Crlf:                "",
		Maquina:             0,
		Padre:               "",
		Paqpadre:            "",
		RelevantTime:        "",
		Desvio:              0,
		Pesoteorico:         0,
		PesoteoricoReal:     0,
		DesvioTeoricoReal:   0,
		FechaImpresion:      "",
		PesoNivel1:          0,
		L3Sended:            false,
		Confirmed:           false,
		SAP:                 false,
	}
}

// Subscribe implements Service.
func (s *service) Subscribe() error {
	srv, err := micro.AddService(s.nc, micro.Config{
		Name:    "BundleService",
		Version: "1.0.0",
		// base handler
		Endpoint: &micro.EndpointConfig{
			Subject: "svc.new.label",
			Handler: micro.HandlerFunc(s.svcNewLabelHandler),
		},
	})
	// handle error
	if err != nil {
		return err
	}
	// set micro
	s.srv = srv
	// done
	return nil
}

// Close implements Service.
func (s *service) Close(ctx context.Context) error {
	if err := s.nc.Flush(); err != nil {
		return err
	}
	s.nc.Close()
	return nil
}

func DataBase(conf *DBConfig) (*gorm.DB, error) {
	// create dsn string
	dsn := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%d sslmode=disable TimeZone=Europe/Madrid",
		conf.Host,
		conf.Username,
		conf.Password,
		conf.Name,
		conf.Port,
	)
	// create open database connection
	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
	if err != nil {
		return nil, err
	}
	return db, nil
}

func AutoMigrate(db *gorm.DB) error {
	return db.AutoMigrate(&types.BundleData{})
}

func New(dbConf *DBConfig, natsConf *NATSConfig) (Service, error) {
	// create data base
	db, err := DataBase(dbConf)
	if err != nil {
		return nil, err
	}
	// auto migrate
	if err := AutoMigrate(db); err != nil {
		return nil, err
	}
	// create nc connection
	nc, err := Nats(natsConf)
	if err != nil {
		return nil, err
	}
	return &service{
		db: db,
		nc: nc,
	}, nil
}