package jadwal_dokter

import (
	cfg "bridging-rssa/config"
	"bridging-rssa/database/satu_data/dokter"
	"bridging-rssa/database/satu_data/jadwal"
	log_api "bridging-rssa/database/satu_data/log_api"
	"bridging-rssa/docs/utils"
	"bridging-rssa/models/bpjs/jadwal_dokter"
	"bridging-rssa/models/config"
	dktr "bridging-rssa/models/dokter"
	logapi "bridging-rssa/models/log_api"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/google/uuid"
	"gorm.io/gorm"

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

func GetJadwalDokter(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("ANTREAN_RS")
	tanggal := c.Param("tanggal")

	// Select from daftar spesialis
	spesialis, err := dokter.GetSpesialis()
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	var listIdSpesialis = make(map[string]int)
	for _, kodeDokter := range spesialis {
		listIdSpesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	subspesialis, err := dokter.GetSubspesialis()
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	var listIdSubspesialis = make(map[string]int)
	for _, kodeDokter := range subspesialis {
		listIdSubspesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	listDokter, err := dokter.GetDokter()
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	var listIddokter = make(map[int]string)
	for _, kodeDokter := range listDokter {
		listIddokter[kodeDokter.HfisCode] = kodeDokter.ID
	}

	var reqInsert *jadwal_dokter.JadwalDokterSatuData
	var response []*jadwal_dokter.JadwalDokterSatuData
	for _, value := range spesialis {
		conf := config.ConfigBpjs{}

		header := cfg.SetHeader(false, conf)

		headers := map[string]string{
			"X-cons-id":   header.ConsID,
			"X-timestamp": header.TimeStamp,
			"X-signature": header.XSignature,
			"user_key":    header.UserKey,
		}
		kdPoly := value.Kode
		url := baseUrl + endpoint
		param := "/jadwaldokter/kodepoli/" + kdPoly + "/tanggal/" + tanggal
		linkurl := url + param
		res, err := JadwalDokterGetResponse(linkurl, header, headers)
		if err != nil {
			log.Println("Error making external API request: %v", err)
			c.JSON(http.StatusInternalServerError, err)
		}
		log.Println("Tanggal :", tanggal)
		if res == nil {
			log.Println("Skip Proses")
			continue
		}
		jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(tanggal)
		if errLibur != nil {
			log.Println(errLibur)
			c.JSON(http.StatusInternalServerError, err)
		}
		if isLibur {
			tanggalTemp, errParseTemp := time.Parse("2006-01-02", tanggal)
			if errParseTemp != nil {
				log.Println(errParseTemp)
				c.JSON(http.StatusInternalServerError, err)
			}
			isLibur = false
			log.Println(jadwalLibur.NamaLiburPelayanan)
			tanggalTemp = tanggalTemp.AddDate(0, 0, 7)
			tanggalTempString := tanggalTemp.Format("2006-01-02")
			log.Println(tanggalTempString)
			paramLibur := "/jadwaldokter/kodepoli/" + kdPoly + "/tanggal/" + tanggalTempString
			linkUrl := url + paramLibur
			resNew, errRes := JadwalDokterGetResponse(linkUrl, header, headers)
			if errRes != nil {
				log.Println("Error making external API request: ", errRes)
				c.JSON(http.StatusInternalServerError, err)
			}
			if resNew != nil {
				for _, v := range resNew.Response {
					res.Response = append(res.Response, &jadwal_dokter.ListDokter{
						KodeSubspesialis: v.KodeSubspesialis,
						Hari:             v.Hari,
						KapasitasPasien:  v.KapasitasPasien,
						Libur:            v.Libur,
						NamaHari:         v.NamaHari,
						Jadwal:           v.Jadwal,
						NamaSubspesialis: v.NamaSubspesialis,
						NamaDokter:       v.NamaDokter,
						KodePoli:         v.KodePoli,
						NamaPoli:         v.NamaPoli,
						KodeDokter:       v.KodeDokter,
					})
				}
			} else {
				log.Println("Tidak ada data pada tanggal ", tanggalTempString)
				continue
			}
		}
		for _, v := range res.Response {
			idSpesialis := utils.KodeToIDConverter(v.KodePoli, listIdSpesialis)
			idSubspesialis := utils.KodeToIDConverter(v.KodeSubspesialis, listIdSubspesialis)
			idDokter := utils.HfisCodeToIDConverter(v.KodeDokter, listIddokter)
			reqInsert = &jadwal_dokter.JadwalDokterSatuData{
				Hari:         v.Hari,
				NamaHari:     v.NamaHari,
				Waktu:        v.Jadwal,
				Dokter:       idDokter,
				Spesialis:    idSpesialis,
				SubSpesialis: idSubspesialis,
				Status:       1, // When available always set to 1
			}
			if reqInsert.Dokter != "" {
				errInsert := dokter.InsertJadwalDokter(reqInsert)
				if errInsert != nil {
					log.Println(errInsert)
					c.JSON(http.StatusInternalServerError, err)
				}
			} else {
				reqInsert.Dokter = strconv.Itoa(v.KodeDokter)
				errInsertTemp := dokter.InsertJadwalDokterTemp(reqInsert)
				if errInsertTemp != nil {
					log.Println(errInsertTemp)
					c.JSON(http.StatusInternalServerError, err)
				}
			}
			response = append(response, reqInsert)
		}
	}
	c.JSON(http.StatusOK, response)
}

func GetDokterByDPJP(c *gin.Context) {
	dpjp := c.Param("dpjp")
	idDokter, err := dokter.GetJadwalDokterByDPJP(dpjp)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
		return
	}

	listHari, err := dokter.GetJadwalHariDokterBySpesialis(idDokter)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
		return
	}

	var IDDokter []string
	var idSubspesialis int
	for _, v := range listHari {
		IDDokter = append(IDDokter, v.Dokter)
		idSubspesialis = v.SubSpesialis
		break
	}

	namaDokter, err := dokter.GetNamaLengkapDokter(IDDokter)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
		return
	}

	listSubspesialis, err := dokter.GetSubspesialisByID(idSubspesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	var res *jadwal_dokter.ResponseListHari

	for _, k := range namaDokter {
		var jadwalDokter []jadwal_dokter.ListJadwalDokter
		for _, key := range listHari {
			jadwalDokter = append(jadwalDokter, jadwal_dokter.ListJadwalDokter{
				NamaHari: key.NamaHari,
				KodeHari: key.Hari,
				Waktu:    key.Waktu,
			})
		}
		gelarDepan := utils.ReplaceGelar(k.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(k.GelarBelakang)
		namaLengkap := gelarDepan + " " + k.NamaLengkap + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		hfisCode := strings.TrimSpace(k.HFISCode)
		res = &jadwal_dokter.ResponseListHari{
			IDSpesialis:    listSubspesialis.IDSpesialis,
			Kode:           listSubspesialis.Kode,
			Spesialis:      listSubspesialis.Spesialis,
			Subspesialis:   listSubspesialis.Subspesialis,
			IDSubspesialis: listSubspesialis.ID,
			NamaLengkap:    namaLengkap,
			HFISCode:       hfisCode,
			KodeDPJP:       dpjp,
			JadwalDokter:   jadwalDokter,
			IDDokter:       k.ID,
		}
	}
	log.Println("Response :", res)
	c.JSON(http.StatusOK, res)
}

func GetJadwalSubspesialisByDate(c *gin.Context) {
	tanggal := c.Param("tanggal")
	date, err := time.Parse("2006-01-02", tanggal)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	log.Println("tanggal: ", tanggal)
	hari := date.Local().Weekday().String()
	hari = utils.ConvertDay(hari)
	idsubspesialis, err := dokter.GetJadwalSubspesialisByDate(hari)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	listSpesialis, err := dokter.GetSubspesialisByIDBatch(idsubspesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	c.JSON(http.StatusOK, listSpesialis)
}

func GetDokterBySpesialis(c *gin.Context) {
	spesialis := c.Param("spesialis")
	tanggal := c.Param("tanggal")
	date, err := time.Parse("2006-01-02", tanggal)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	hari := date.Local().Weekday().String()
	hari = utils.ConvertDay(hari)
	idDokter, err := dokter.GetJadwalDokterBySpesialis(hari, spesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	namaDokter, err := dokter.GetNamaLengkapDokter(idDokter)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	var resDokter []dktr.ResponseDokter
	idSpesialis, err := strconv.Atoi(spesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	for _, v := range namaDokter {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkap + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		resDokter = append(resDokter, dktr.ResponseDokter{
			ID:          v.ID,
			NamaLengkap: namaLengkap,
			Spesialis:   idSpesialis,
			HFISCode:    v.HFISCode,
		})
	}
	log.Println("Response :", resDokter)
	c.JSON(http.StatusOK, resDokter)
}

func GetDokterBySubspesialis(c *gin.Context) {
	subspesialis := c.Param("subspesialis")
	tanggal := c.Param("tanggal")
	date, err := time.Parse("2006-01-02", tanggal)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	log.Println("subspesialis: ", subspesialis)
	log.Println("tanggal: ", tanggal)

	hari := date.Local().Weekday().String()
	hari = utils.ConvertDay(hari)
	idDokter, err := dokter.GetJadwalDokterBySubpesialis(hari, subspesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	namaDokter, err := dokter.GetNamaLengkapDokter(idDokter)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}
	var resDokter []dktr.ResponseDokterNew
	idSubspesialis, err := strconv.Atoi(subspesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	listSubspesialis, err := dokter.GetSubspesialisByID(idSubspesialis)
	if err != nil {
		c.JSON(http.StatusInternalServerError, err)
	}

	for _, v := range namaDokter {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkap + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		resDokter = append(resDokter, dktr.ResponseDokterNew{
			ID:           v.ID,
			NamaLengkap:  namaLengkap,
			Subspesialis: idSubspesialis,
			HFISCode:     v.HFISCode,
			KodePoli:     listSubspesialis.Kode,
			DPJPCode:     v.DPJPCode,
		})
	}
	log.Println("Response :", resDokter)
	c.JSON(http.StatusOK, resDokter)
}

func GetDataJadwalDokter() bool {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("ANTREAN_RS")

	conf := config.ConfigBpjs{}

	spesialis, err := dokter.GetSpesialis()
	if err != nil {
		log.Println("Error getting spesialis", err)
		return false
	}

	var listIdSpesialis = make(map[string]int)
	for _, kodeDokter := range spesialis {
		listIdSpesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	subspesialis, err := dokter.GetSubspesialis()
	if err != nil {
		log.Println("Error getting subspesialis", err)
		return false
	}

	var listIdSubspesialis = make(map[string]int)
	for _, kodeDokter := range subspesialis {
		listIdSubspesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	listDokter, err := dokter.GetDokter()
	if err != nil {
		log.Println("Error getting dokter", err)
		return false
	}

	var listIddokter = make(map[int]string)
	for _, kodeDokter := range listDokter {
		listIddokter[kodeDokter.HfisCode] = kodeDokter.ID
	}
	db := cfg.SatuDataDB
	errTx := db.Transaction(func(tx *gorm.DB) error {
		errTruncate := dokter.TruncateDataJadwalDokter()
		if errTruncate != nil {
			log.Println(errTruncate)
			return errTruncate
		}
		for _, value := range spesialis {
			url := baseUrl + endpoint + "/jadwaldokter/kodepoli/" + value.Kode

			header := cfg.SetHeader(false, conf)

			headers := map[string]string{
				"X-cons-id":   header.ConsID,
				"X-timestamp": header.TimeStamp,
				"X-signature": header.XSignature,
				"user_key":    header.UserKey,
			}

			log.Println("Headers : ", headers)
			var headerStringBuilder strings.Builder
			for key, value := range headers {
				headerStringBuilder.WriteString(fmt.Sprintf("%s: %s; ", key, value))
			}
			headerString := strings.TrimSuffix(headerStringBuilder.String(), "; ")

			startDate := time.Now()
			endDate := startDate.AddDate(0, 3, 0)
			logTimeStart := time.Now().Format("2006-01-02 15:04:05")
			var res *jadwal_dokter.JadwalDokter
			var reqLog []*jadwal_dokter.RequestJadwalDokter
			var resLog []*jadwal_dokter.JadwalDokter

			for current := startDate; current.Before(endDate); current = current.AddDate(0, 0, 1) {
				tanggal := current.Format("2006-01-02")
				log.Println("Tanggal :", tanggal)
				urlReq := url + "/tanggal/" + tanggal

				res, err = JadwalDokterGetResponse(urlReq, header, headers)
				if err != nil {
					log.Printf("Error making external API request: %v", err)
					return err
				}

				reqLog = append(reqLog, &jadwal_dokter.RequestJadwalDokter{
					KodePoli: value.Kode,
					Tanggal:  tanggal,
				})

				resLog = append(resLog, &jadwal_dokter.JadwalDokter{
					Response: res.Response,
					MetaData: res.MetaData,
				})

				if res.MetaData.Code != 200 {
					resLog = append(resLog, &jadwal_dokter.JadwalDokter{
						Response: res.Response,
						MetaData: res.MetaData,
					})
					continue
				}

				for _, v := range res.Response {
					idSpesialis := utils.KodeToIDConverter(v.KodePoli, listIdSpesialis)
					idSubspesialis := utils.KodeToIDConverter(v.KodeSubspesialis, listIdSubspesialis)
					idDokter := utils.HfisCodeToIDConverter(v.KodeDokter, listIddokter)
					reqInsert := &jadwal_dokter.DataJadwalDokterSatuData{
						ID:            uuid.NewString(),
						DateCreated:   logTimeStart,
						Hari:          strconv.Itoa(v.Hari),
						NamaHari:      v.NamaHari,
						Waktu:         v.Jadwal,
						Dokter:        idDokter,
						Spesialis:     idSpesialis,
						SubSpesialis:  idSubspesialis,
						TanggalJadwal: tanggal,
					}
					if reqInsert.Dokter != "" {
						errInsert := dokter.InsertDataJadwalDokter(tx, reqInsert)
						if errInsert != nil {
							log.Println(errInsert)
							return errInsert
						}
					} else {
						log.Println("Dokter tidak punya HFIS")
						continue
					}
				}
			}

			reqLogJson, errMarshal := json.Marshal(reqLog)
			if errMarshal != nil {
				log.Println(errMarshal)
				return errMarshal
			}
			resLogJson, errMarshal2 := json.Marshal(resLog)
			if errMarshal2 != nil {
				log.Println(errMarshal2)
				return errMarshal2
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			reqLogApi := &logapi.DataLogAPI{
				ID:              uuid.NewString(),
				DateCreated:     logTimeEnd,
				Parameter:       "BPJS-AntreanRS-JadwalDokter",
				Header:          headerString,
				Method:          "GET",
				Url:             url,
				Request:         reqLogJson,
				Respon:          resLogJson,
				ResponCode:      strconv.Itoa(res.MetaData.Code),
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}
			errLog := log_api.InsertLogAPI(reqLogApi)
			if errLog != nil {
				log.Printf("Error making external API request: %v", err)
				return errLog
			}
		}
		return nil
	})
	if errTx != nil {
		log.Println(errTx)
		return false
	}
	log.Println("Berhasil ambil jadwal data dokter")
	return true
}

func GetJadwalDokterNew() bool {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("ANTREAN_RS")
	url := baseUrl + endpoint

	errTruncate := dokter.DeleteJadwalDokter()
	if errTruncate != nil {
		log.Println(errTruncate)
		return false
	}

	errTruncateTemp := dokter.DeleteJadwalDokterTemp()
	if errTruncateTemp != nil {
		log.Println(errTruncateTemp)
		return false
	}

	// Select from daftar spesialis
	spesialis, err := dokter.GetSpesialis()
	if err != nil {
		return false
	}

	var listIdSpesialis = make(map[string]int)
	for _, kodeDokter := range spesialis {
		listIdSpesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	subspesialis, err := dokter.GetSubspesialis()
	if err != nil {
		return false
	}

	var listIdSubspesialis = make(map[string]int)
	for _, kodeDokter := range subspesialis {
		listIdSubspesialis[kodeDokter.Kode] = kodeDokter.ID
	}

	listDokter, err := dokter.GetDokter()
	if err != nil {
		return false
	}

	var listIddokter = make(map[int]string)
	for _, kodeDokter := range listDokter {
		listIddokter[kodeDokter.HfisCode] = kodeDokter.ID
	}

	var reqInsert *jadwal_dokter.JadwalDokterSatuData

	for _, value := range spesialis {

		tanggal := time.Now().Format("2006-01-02")
		// tanggal := "2025-04-11"
		for i := 0; i < 7; i++ {
			conf := config.ConfigBpjs{}

			header := cfg.SetHeader(false, conf)

			headers := map[string]string{
				"X-cons-id":   header.ConsID,
				"X-timestamp": header.TimeStamp,
				"X-signature": header.XSignature,
				"user_key":    header.UserKey,
			}
			kdPoly := value.Kode
			param := "/jadwaldokter/kodepoli/" + kdPoly + "/tanggal/" + tanggal
			linkurl := url + param
			res, err := JadwalDokterGetResponseApi(linkurl, header, headers)
			if err != nil {
				log.Println("Error making external API request: %v", err)
				return false
			}
			date, errParse := time.Parse("2006-01-02", tanggal)
			if errParse != nil {
				return false
			}
			tanggal = date.AddDate(0, 0, 1).Format("2006-01-02")
			log.Println("Tanggal :", tanggal)
			if res == nil {
				log.Println("Skip Proses")
				continue
			}
			jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(tanggal)
			if errLibur != nil {
				log.Println(errLibur)
				return false
			}
			if isLibur {
				tanggalTemp, errParseTemp := time.Parse("2006-01-02", tanggal)
				if errParseTemp != nil {
					log.Println(errParseTemp)
					return false
				}
				isLibur = false
				for i := 0; i < 7; i++ {
					log.Println(jadwalLibur.NamaLiburPelayanan)
					tanggalTemp = tanggalTemp.AddDate(0, 0, 7)
					tanggalTempString := tanggalTemp.Format("2006-01-02")
					log.Println(tanggalTempString)
					paramLibur := "/jadwaldokter/kodepoli/" + kdPoly + "/tanggal/" + tanggalTempString
					linkUrl := url + paramLibur
					resNew, errRes := JadwalDokterGetResponseApi(linkUrl, header, headers)
					if errRes != nil {
						log.Println("Error making external API request: ", errRes)
						return false
					}
					if resNew != nil {
						for _, v := range resNew {
							res = append(res, &jadwal_dokter.ListDokter{
								KodeSubspesialis: v.KodeSubspesialis,
								Hari:             v.Hari,
								KapasitasPasien:  v.KapasitasPasien,
								Libur:            v.Libur,
								NamaHari:         v.NamaHari,
								Jadwal:           v.Jadwal,
								NamaSubspesialis: v.NamaSubspesialis,
								NamaDokter:       v.NamaDokter,
								KodePoli:         v.KodePoli,
								NamaPoli:         v.NamaPoli,
								KodeDokter:       v.KodeDokter,
							})
						}
						log.Println("Ada data pada tanggal ", tanggalTempString)
						break
					} else {
						log.Println("Tidak ada data pada tanggal ", tanggalTempString)
						continue
					}
				}
			}
			for _, v := range res {
				idSpesialis := utils.KodeToIDConverter(v.KodePoli, listIdSpesialis)
				idSubspesialis := utils.KodeToIDConverter(v.KodeSubspesialis, listIdSubspesialis)
				idDokter := utils.HfisCodeToIDConverter(v.KodeDokter, listIddokter)
				reqInsert = &jadwal_dokter.JadwalDokterSatuData{
					Hari:         v.Hari,
					NamaHari:     v.NamaHari,
					Waktu:        v.Jadwal,
					Dokter:       idDokter,
					Spesialis:    idSpesialis,
					SubSpesialis: idSubspesialis,
					Status:       1, // When available always set to 1
				}
				if reqInsert.Dokter != "" {
					errInsert := dokter.InsertJadwalDokter(reqInsert)
					if errInsert != nil {
						log.Println(errInsert)
						return false
					}
				} else {
					reqInsert.Dokter = strconv.Itoa(v.KodeDokter)
					errInsertTemp := dokter.InsertJadwalDokterTemp(reqInsert)
					if errInsertTemp != nil {
						log.Println(errInsertTemp)
						return false
					}
				}
			}
		}
	}
	return true
}