package specialist

import (
	"bytes"
	"encoding/json"
	"log"
	"net/http"
	db "simrs-vx/pkg/dualtrx-helper"
	pl "simrs-vx/pkg/logger"
	"strconv"

	es "simrs-vx/internal/domain/main-entities/specialist"
	er "simrs-vx/internal/domain/simgos-entities/m-ruang"

	us "simrs-vx/internal/use-case/simgos-sync-use-case/new/specialist"
	"simrs-vx/internal/use-case/simgos-sync-use-case/seeder"
)

func SeedSpecialist(event *pl.Event, tx *db.Dualtx) error {
	ruang := []er.MRuang{}

	// Get M_Ruang
	err := tx.Simgos.Model(&er.MRuang{}).
		Find(&ruang).Error
	if err != nil {
		log.Println("Error Querying MRuang:", err)
		return err
	}

	// Mapping To Specialist
	var speData []es.CreateDto
	for _, v := range ruang {
		if v.StAktif == 0 {
			continue
		}

		speCode := strconv.Itoa(int(v.No))

		var insCode *string
		if v.KdUnit != 0 {
			code := strconv.Itoa(v.KdUnit)
			insCode = &code
		}

		speData = append(speData, es.CreateDto{
			Code:              speCode,
			Name:              v.Nama,
			Installation_Code: insCode,
		})
	}

	dataSpe, err := CreateBulkSpecialist(es.CreateBulkDto{Value: speData})
	if err != nil {
		return err
	}

	_, err = us.CreateBulkLinkData(dataSpe, event, tx.Sync)
	if err != nil {
		return err
	}

	return nil

}

func CreateBulkSpecialist(ins es.CreateBulkDto) ([]es.Specialist, error) {
	var path = "specialist/bulk"

	// create request body
	jsonData, err := json.Marshal(ins)
	if err != nil {
		return nil, err
	}

	reqBody := bytes.NewBuffer(jsonData)
	// send data to main-api
	resp, err := seeder.Send(http.MethodPost, path, reqBody, "von")
	if err != nil {
		return nil, err
	}

	type MetaData struct {
		Source    string `json:"source"`
		Status    string `json:"status"`
		Structure string `json:"structure"`
	}

	type MainApiResp struct {
		Meta MetaData        `json:"meta"`
		Data []es.Specialist `json:"data"`
	}

	// getting response
	var data MainApiResp
	err = json.Unmarshal(resp, &data)
	if err != nil {
		return nil, err
	}

	return data.Data, nil
}