package suratkontrol

import (
	cfg "bridging-rssa/config"
	"bridging-rssa/database/satu_data/jadwal"
	log_api "bridging-rssa/database/satu_data/log_api"
	lokasiruang "bridging-rssa/database/satu_data/lokasi_ruang"
	suratkontrol "bridging-rssa/database/satu_data/surat_kontrol"
	"bridging-rssa/docs/utils"
	"bridging-rssa/handlers/bpjs"
	sk "bridging-rssa/models/bpjs/surat_kontrol"
	"bridging-rssa/models/config"
	logapi "bridging-rssa/models/log_api"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"
	"time"

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

func Coba(c *gin.Context) {
	var req sk.IDXDAFTAR

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
	}
	log.Println(req)
	dataAdmission, erradmission := suratkontrol.GetAdmission(req.IDXDAFTAR)
	log.Println("hasillll", dataAdmission)
	if erradmission != nil {
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
	}
	log.Println(err)
	c.JSON(http.StatusOK, dataAdmission)
}

func Parse(c *gin.Context) {
	var req sk.Parse
	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	NamaDiagnosaString := strings.TrimSpace("M86.9 - Osteomyelitis, unspecified")
	parts := strings.SplitN(NamaDiagnosaString, " - ", 2)
	var kodeICD, diagnosa string
	if len(parts) == 2 {
		kodeICD = parts[0]
		diagnosa = parts[1]
	} else {
		kodeICD = req.Diagnosa
		diagnosa = ""
	}
	log.Println("belum di parse:", req.Diagnosa)
	log.Println("kodeICD : ", kodeICD)
	log.Println("diagnosa : ", diagnosa)

}

func InsertSuratkontrolNew(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	//baseUrl := os.Getenv("BASEURL_BPJS_DEV")
	//endpoint := os.Getenv("VCLAIM_RS_DEV")
	param := os.Getenv("INSERT_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	timeNow := time.Now().Format("2006-01-02 15:04:05")
	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")

	var req sk.RequestInsertRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: "Hari Libur " + jadwalLibur.NamaLiburPelayanan,
		})
		return
	}
	uuid := uuid.New().String()

	var kunjunganPasien *sk.KunjunganPasien
	kunjunganPasien, err = suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		if err.Error() == "Data Tidak Ditemukan" {
			dataAdmission, erradmission := suratkontrol.GetAdmission(req.IDXDaftar)
			log.Println("kesini kagh", dataAdmission)
			if erradmission != nil {
				log.Println("masuk sini")
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Pasien Tidak Ada Kunjungan",
				})
				return
			}
			IdDokter, err := suratkontrol.Getdokter(dataAdmission.DokterPengirim)
			log.Println("ID E DOKTER", IdDokter)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Dokter tidak Ditemukan di satudata",
				})
				return
			}
			layout := "2006-01-02 15:04:05" // sesuaikan format string input

			masukrsTime, err := time.Parse(layout, dataAdmission.MasukRS)
			Tanggalmasuk := masukrsTime.Format("2006-01-02")
			Jammasuk := masukrsTime.Format("15:04:05")
			insertKunjungan := &sk.InsertKunjunganPasien{
				ID:           uuid,
				IdxDaftar:    dataAdmission.ID,
				Nomr:         dataAdmission.Nomr,
				NamaLengkap:  dataAdmission.NamaLengkap,
				NIK:          dataAdmission.NoKTP,
				DPJP:         IdDokter,
				TanggalMasuk: Tanggalmasuk,
				JamMasuk:     Jammasuk,
				DateCreated:  timeNow,
			}
			log.Println("Insert Kunjungan:", insertKunjungan)
			err = suratkontrol.InsertKunjunganPasien(insertKunjungan)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Server Pasien Sedang Down",
				})
				return
			}
			kunjunganPasien, err = suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
			log.Println("Kunjungan Pasien ke 2:", kunjunganPasien)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Kunjungan Pasien Kosong",
				})
				return
			}
		}
	}

	var idRuangan int
	if kunjunganPasien.Ruangan != 0 {
		idRuangan = kunjunganPasien.Ruangan
	} else {
		idRuangan, err = lokasiruang.GetDaftarLokasiRuang(req.Ruangan)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}

	if req.TipeSurKon == "2" {
		reqJson, err := json.Marshal(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println("reqJson : ", string(reqJson))

		reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
			Request: &sk.ReqInsertRencanaKontrol{
				NoSEP:             req.NoSEP,
				KodeDokter:        req.KodeHFIS,
				PoliKontrol:       req.KodePoli,
				TglRencanaKontrol: req.TglRencanaKontrol,
				User:              req.User,
			},
		}
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		res, errData := PostData(url, header, headers, reqSuratKontrol)
		log.Println("res : ", res)
		if errData != nil {
			responJson, err := json.Marshal(res)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "201",
						Message: err.Error(),
					},
				})
				return
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "BPJS-VClaim-RencanaKontrol",
				Header:          headerString,
				Method:          "POST",
				Url:             url,
				Request:         reqJson,
				Respon:          responJson,
				ResponCode:      res.MetaData.Code,
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}

			if res.MetaData.Code == "500" {
				c.JSON(http.StatusInternalServerError, &sk.MetadataString{
					Code:    "500",
					Message: "Server Bpjs Down",
				})
				return
			}
			log.Println(err)
			bpjs.HandleResponse(c, res)
			return
		}

		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}

		idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		NamaDiagnosaString := strings.TrimSpace(res.Response.NamaDiagnosa)
		parts := strings.SplitN(NamaDiagnosaString, " - ", 2)
		var kodeICD, diagnosa string
		if len(parts) == 2 {
			kodeICD = parts[0]
			diagnosa = parts[1]
		} else {
			kodeICD = res.Response.NamaDiagnosa
			diagnosa = ""
		}
		log.Println("kodeICD : ", kodeICD)
		log.Println("diagnosa : ", diagnosa)

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NomorSurKon:       res.Response.NoSuratKontrol,
			NomorKartu:        res.Response.NoKartu,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     idRuangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			UserCreatedSurKon: req.User,
			TipeSurKon:        req.TipeSurKon,
			TipeRawat:         req.TipeRawat,
			KodeIcd:           kodeICD,
			Diagnosa:          diagnosa,
		}
		log.Println(reqInsert)
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		err = suratkontrol.UpdateKunjunganPasien(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		response := &sk.ResponseInsertSuratKontrol{
			MetaData: res.MetaData,
			Response: sk.ResponseData{
				NoSuratKontrol:    res.Response.NoSuratKontrol,
				TglRencanaKontrol: res.Response.TglRencanaKontrol,
				NamaDokter:        res.Response.NamaDokter,
				NoKartu:           res.Response.NoKartu,
				Nama:              res.Response.Nama,
				Kelamin:           res.Response.Kelamin,
				TglLahir:          res.Response.TglLahir,
				NamaDiagnosa:      res.Response.NamaDiagnosa,
				SubSpesialis:      req.Subspesialis,
			},
		}

		log.Println("Response: ", response)
		c.JSON(http.StatusOK, response)
	} else {

		var dataSurkon string
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			if err.Error() == "Data tidak ada" {
				dataSurkon, err = suratkontrol.GetNomorSurKonnew(req.IDXDaftar)
				if err != nil {

				}
			}
		}

		noUrut := "001"
		if dataSurkon != "" {
			noUrut, err = utils.GetNoUrut(dataSurkon)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}
		}
		idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		noSurKon := "SI/" + req.TipeRawat + "/" + req.NoRM + "/" + noUrut
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       noSurKon,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     idRuangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			UserCreatedSurKon: req.User,
			TipeSurKon:        req.TipeSurKon,
			TipeRawat:         req.TipeRawat,
		}
		log.Println("INI SURAT INTERNAL", reqInsert)
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			reqJsoninternal, err := json.Marshal(reqInsert)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "203",
						Message: err.Error(),
					},
				})
				return
			}

			log.Println("reqJson : ", string(reqJsoninternal))

			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "Surat Kontrol Internal",
				Header:          headerString,
				Method:          "POST",
				Url:             url,
				Request:         reqJsoninternal,
				Respon:          reqJsoninternal,
				ResponCode:      "200",
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         "",
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}

			return
		}

		reqJsoninternal, err := json.Marshal(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println("reqJson : ", string(reqJsoninternal))

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "Surat Kontrol Internal",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJsoninternal,
			Respon:          reqJsoninternal,
			ResponCode:      "200",
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         "Berhasil Insert SuratKontrol",
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		err = suratkontrol.UpdateKunjunganPasien(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "200",
				Message: "Berhasil Insert Surat Kontrol",
			},
		})
		return
	}
}

func InsertSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("INSERT_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	var req sk.RequestInsertRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}
	log.Println(req)

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: errLibur.Error(),
			},
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: jadwalLibur.NamaLiburPelayanan,
			},
		})
		return
	}

	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	log.Println("Request: ", string(reqJson))

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	var idRuangan int
	if kunjunganPasien.Ruangan != 0 {
		idRuangan = kunjunganPasien.Ruangan
	} else {
		idRuangan, err = lokasiruang.GetDaftarLokasiRuang(req.Ruangan)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
	}

	uuid := uuid.New().String()
	if req.TipeSurKon != "1" {
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}

		noUrut := "001"
		if dataSurkon != "" {
			noUrut, err = utils.GetNoUrut(dataSurkon)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "203",
						Message: err.Error(),
					},
				})
				return
			}
		}

		noSurKon := "SI/" + req.TipeRawat + "/" + kunjunganPasien.NomorRM + "/" + noUrut
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       noSurKon,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     idRuangan,
			DPJPSurKon:        req.IDDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			UserCreatedSurKon: req.User,
			KodeIcd:           kunjunganPasien.DiagnosisPrimerUtama,
			Diagnosa:          kunjunganPasien.DisplayDiagnosisPrimerUtama,
			TipeSurKon:        req.TipeSurKon,
			TipeRawat:         req.TipeRawat,
		}
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		reqJsoninternal, err := json.Marshal(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println("reqJson : ", string(reqJsoninternal))

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "Surat Kontrol Internal",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJsoninternal,
			Respon:          reqJsoninternal,
			ResponCode:      "200",
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         "Berhasil Insert SuratKontrol",
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		err = suratkontrol.UpdateKunjunganPasien(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "200",
				Message: "Berhasil Insert Surat Kontrol",
			},
		})
		return
	}

	reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.ReqInsertRencanaKontrol{
			NoSEP:             req.NoSEP,
			KodeDokter:        req.KodeHFIS,
			PoliKontrol:       req.KodePoli,
			TglRencanaKontrol: req.TglRencanaKontrol,
			User:              req.User,
		},
	}
	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := PostData(url, header, headers, reqSuratKontrol)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: res.MetaData,
		})
		return
	}

	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	NamaDiagnosaString := strings.TrimSpace(res.Response.NamaDiagnosa)
	parts := strings.SplitN(NamaDiagnosaString, " - ", 2)
	var kodeICD, diagnosa string
	if len(parts) == 2 {
		kodeICD = parts[0]
		diagnosa = parts[1]
	} else {
		kodeICD = res.Response.NamaDiagnosa
		diagnosa = ""
	}
	log.Println("kodeICD : ", kodeICD)
	log.Println("diagnosa : ", diagnosa)

	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
	reqInsert := &sk.DataSuratKontrol{
		ID:                uuid,
		DateCreated:       timeNow,
		TglCetakSurKon:    timeNow,
		TglRencanaKontrol: res.Response.TglRencanaKontrol,
		NomorSurKon:       res.Response.NoSuratKontrol,
		KunjunganPasien:   kunjunganPasien.ID,
		RuanganSurKon:     idRuangan,
		DPJPSurKon:        req.IDDokter,
		NomorKartu:        res.Response.NoKartu,
		StatusSurKon:      1, // First Insert status always set to 1
		UserCreatedSurKon: req.User,
		TipeSurKon:        req.TipeSurKon,
		TipeRawat:         req.TipeRawat,
		KodeIcd:           kodeICD,
		Diagnosa:          diagnosa,
	}

	err = suratkontrol.InsertDataSuratKontrol(reqInsert)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	if req.KodeDiagnosa == "" || req.NamaDiagnosa == "" {
		diagnosa := strings.Split(res.Response.NamaDiagnosa, " - ")
		req.KodeDiagnosa = diagnosa[0]
		req.NamaDiagnosa = diagnosa[1]
	}

	err = suratkontrol.UpdateKunjunganPasien(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "POST",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	response := &sk.ResponseInsertSuratKontrol{
		MetaData: res.MetaData,
		Response: sk.ResponseData{
			NoSuratKontrol:    res.Response.NoSuratKontrol,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NamaDokter:        res.Response.NamaDokter,
			NoKartu:           res.Response.NoKartu,
			Nama:              res.Response.Nama,
			Kelamin:           res.Response.Kelamin,
			TglLahir:          res.Response.TglLahir,
			NamaDiagnosa:      res.Response.NamaDiagnosa,
			SubSpesialis:      req.Subspesialis,
		},
	}

	log.Println("Response: ", response)
	c.JSON(http.StatusOK, response)
}

func UpdateSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("UPDATE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	var req sk.RequestUpdateRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: jadwalLibur.NamaLiburPelayanan,
		})
		return
	}

	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("Request: ", string(reqJson))

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	UserCreated, err := suratkontrol.GetUserCreated(req.IDSurKon)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
	}

	dateRencanaSurkon, _ := time.Parse(time.RFC3339, UserCreated.TanggalKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	log.Println("tanggal database : ", dateRencanaSurkonString)
	log.Println("tanggal req:", req.TglRencanaKontrol)
	if req.TglRencanaKontrol == dateRencanaSurkonString {
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: "Tanggal tidak boleh sama ! silahkan pilih tanggal yang lain",
		})
		return
	}
	dateCetakSurkon, _ := time.Parse(time.RFC3339, UserCreated.DataCreate)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")

	uuid := uuid.New().String()
	if req.TipeSurKon != "1" {
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}

		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       dateCetakSurkonString,
			DateUpdated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       dataSurkon, //TODO How to get Nomor SurKon
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     kunjunganPasien.Ruangan,
			DPJPSurKon:        req.IDDokter,
			KodeIcd:           kunjunganPasien.DiagnosisPrimerUtama,
			Diagnosa:          kunjunganPasien.DisplayDiagnosisPrimerUtama,
			StatusSurKon:      1, // First Insert status always set to 1
			TipeSurKon:        req.TipeSurKon,
			UserCreated:       UserCreated.UserCreate,
			UserUpdatedSurKon: req.User,
			TipeRawat:         req.TipeRawat,
		}
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDSurKon,
			StatusSurKon:      2,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}

		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqJsoninternal, err := json.Marshal(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println("reqJson : ", string(reqJsoninternal))

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "Surat Kontrol Internal",
			Header:          "",
			Method:          "PUT",
			Url:             url,
			Request:         reqJsoninternal,
			Respon:          reqJsoninternal,
			ResponCode:      "200",
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         "Berhasil Update SuratKontrol",
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		c.JSON(http.StatusOK, &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Update Surat Kontrol",
		})
		return
	}

	log.Println("Request: ", reqJson)

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")

	reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.ReqUpdateRencanaKontrol{
			NoSuratKontrol:    req.NoSuratKontrol,
			NoSEP:             req.NoSEP,
			KodeDokter:        req.KodeHFIS,
			PoliKontrol:       req.KodePoli,
			TglRencanaKontrol: req.TglRencanaKontrol,
			User:              req.User,
		},
	}

	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := ResponseUpdateSuratKontrol(url, header, headers, reqSuratKontrol)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		if res.MetaData.Code == "504" {
			log.Println(err)
			c.JSON(http.StatusGatewayTimeout, res.MetaData)
			return
		}
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "PUT",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		log.Println(err)
		c.JSON(http.StatusInternalServerError, res.MetaData)
		return
	}
	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")

	reqUpdate := &sk.DataSuratKontrol{
		DateUpdated:       timeNow,
		ID:                req.IDSurKon,
		StatusSurKon:      2,
		UserUpdatedSurKon: req.User,
	}

	err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	NamaDiagnosaString := strings.TrimSpace(res.Response.NamaDiagnosa)
	parts := strings.SplitN(NamaDiagnosaString, " - ", 2)
	var kodeICD, diagnosa string
	if len(parts) == 2 {
		kodeICD = parts[0]
		diagnosa = parts[1]
	} else {
		kodeICD = res.Response.NamaDiagnosa
		diagnosa = ""
	}
	log.Println("kodeICD : ", kodeICD)
	log.Println("diagnosa : ", diagnosa)

	reqInsert := &sk.DataSuratKontrol{
		ID:                uuid,
		DateCreated:       dateCetakSurkonString,
		DateUpdated:       timeNow,
		TglCetakSurKon:    timeNow,
		TglRencanaKontrol: res.Response.TglRencanaKontrol,
		NomorSurKon:       res.Response.NoSuratKontrol,
		KunjunganPasien:   kunjunganPasien.ID,
		RuanganSurKon:     kunjunganPasien.Ruangan,
		NomorKartu:        res.Response.NoKartu,
		DPJPSurKon:        req.IDDokter,
		StatusSurKon:      1, // Insert status always set to 1
		TipeSurKon:        "1",
		UserCreated:       UserCreated.UserCreate,
		UserUpdatedSurKon: req.User,
		KodeIcd:           kodeICD,
		Diagnosa:          diagnosa,
	}

	if reqInsert.DPJPSurKon == "" {
		reqInsert.DPJPSurKon = kunjunganPasien.DPJP
	}

	err = suratkontrol.InsertDataSuratKontrol(reqInsert)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "PUT",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, res)
}

func UpdateSuratKontrolnew(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")

	//baseUrl := os.Getenv("BASEURL_BPJS_DEV")
	//endpoint := os.Getenv("VCLAIM_RS_DEV")
	param := os.Getenv("UPDATE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")

	var req sk.RequestUpdateRencanaKontrolNew

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "203",
			Message: err.Error(),
		})
		return
	}

	jadwalLibur, isLibur, errLibur := jadwal.GetJadwalLibur(req.TglRencanaKontrol)
	if errLibur != nil {
		log.Println(errLibur)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	} else if isLibur {
		log.Println(jadwalLibur.KeteranganLiburPelayanan)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: "Hari Libur " + jadwalLibur.NamaLiburPelayanan,
		})
		return
	}
	timeNow := time.Now().Format("2006-01-02 15:04:05")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}
	UserCreated, err := suratkontrol.GetUserCreated(req.IDSurKon)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
	}
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, UserCreated.TanggalKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	log.Println("tanggal database : ", dateRencanaSurkonString)
	log.Println("tanggal req:", req.TglRencanaKontrol)
	if req.TglRencanaKontrol == dateRencanaSurkonString {
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: "Tanggal tidak boleh sama ! silahkan pilih tanggal yang lain",
		})
		return
	}
	dateCetakSurkon, _ := time.Parse(time.RFC3339, UserCreated.DataCreate)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02 15:04:05")

	if strings.HasPrefix(strings.ToUpper(req.NoSuratKontrol), "SI") {
		req.TipeSurKon = "1"
	}

	uuid := uuid.New().String()
	if req.TipeSurKon == "2" {
		reqJson, err := json.Marshal(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			})
			return
		}
		log.Println("reqJson : ", string(reqJson))

		reqSuratKontrol := &sk.RequestHeaderRencanaKontrol{
			Request: &sk.ReqUpdateRencanaKontrol{
				NoSuratKontrol:    req.NoSuratKontrol,
				NoSEP:             req.NoSEP,
				KodeDokter:        req.KodeHFIS,
				PoliKontrol:       req.KodePoli,
				TglRencanaKontrol: req.TglRencanaKontrol,
				User:              req.User,
			},
		}
		log.Println("reqJson : ", reqSuratKontrol)

		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		res, errData := ResponseUpdateSuratKontrol(url, header, headers, reqSuratKontrol)
		log.Println("error nya", errData)
		log.Println("ResponseUpdateSuratKontrol: ", res)
		if errData != nil {
			responJson, err := json.Marshal(res)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusInternalServerError, &sk.MetadataString{
					Code:    res.MetaData.Code,
					Message: res.MetaData.Message,
				})
				return
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			if res.MetaData.Code == "504" {
				log.Println(err)
				c.JSON(http.StatusGatewayTimeout, res.MetaData)
				return
			}

			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "BPJS-VClaim-RencanaKontrol",
				Header:          headerString,
				Method:          "PUT",
				Url:             url,
				Request:         reqJson,
				Respon:          responJson,
				ResponCode:      res.MetaData.Code,
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}
			log.Println(err)

			bpjs.HandleResponse(c, res)

			return
		}
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDSurKon,
			StatusSurKon:      2,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
		}

		parts := strings.SplitN(res.Response.NamaDiagnosa, " - ", 2)
		var kodeICD, diagnosa string
		if len(parts) == 2 {
			kodeICD = parts[0]
			diagnosa = parts[1]
		} else {
			kodeICD = res.Response.NamaDiagnosa
			diagnosa = ""
		}

		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateUpdated:       timeNow,
			DateCreated:       dateCetakSurkonString,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NomorSurKon:       res.Response.NoSuratKontrol,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     kunjunganPasien.Ruangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // Insert status always set to 1
			TipeSurKon:        req.TipeSurKon,
			TipeRawat:         req.TipeRawat,
			UserCreatedSurKon: UserCreated.UserCreate,
			UserUpdatedSurKon: req.User,
			KodeIcd:           kodeICD,
			Diagnosa:          diagnosa,
		}

		if reqInsert.DPJPSurKon == "" {
			reqInsert.DPJPSurKon = kunjunganPasien.DPJP
		}

		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "PUT",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}
		log.Println("MASUK LOG DISINI: ", reqInsertLog)

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		log.Println("RESPON: ", res)
		bpjs.HandleResponse(c, res)

	} else {
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDSurKon,
			StatusSurKon:      2,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		UserCreated, err := suratkontrol.GetUserCreated(req.IDSurKon)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
		}
		idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
		}
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       dateCetakSurkonString,
			DateUpdated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: req.TglRencanaKontrol,
			NomorSurKon:       dataSurkon, //TODO How to get Nomor SurKon
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     kunjunganPasien.Ruangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			TipeSurKon:        req.TipeSurKon,
			UserCreatedSurKon: UserCreated.UserCreate,
			UserUpdatedSurKon: req.User,
			TipeRawat:         req.TipeRawat,
		}
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqJsoninternal, err := json.Marshal(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		log.Println("reqJson : ", string(reqJsoninternal))

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "Surat Kontrol Internal",
			Header:          headerString,
			Method:          "PUT",
			Url:             url,
			Request:         reqJsoninternal,
			Respon:          reqJsoninternal,
			ResponCode:      "200",
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         "Berhasil Update SuratKontrol",
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		c.JSON(http.StatusOK, &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Update Surat Kontrol",
		})
		return

	}
}

func DeleteSuratKontrolNew(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")

	//baseUrl := os.Getenv("BASEURL_BPJS_DEV")
	//endpoint := os.Getenv("VCLAIM_RS_DEV")
	param := os.Getenv("DELETE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")
	var req sk.ReqDeleteRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("REQUEST: ", req)

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	if req.TipeSurKon == "2" {
		reqJson, err := json.Marshal(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		log.Println("ini reqjson nya:", reqJson)

		request := &sk.RequestHeaderRencanaKontrol{
			Request: &sk.TSuratKontrol{
				RequestDelete: sk.RequestDeleteRencanaKontrol{
					NoSuratKontrol: req.NomorSurKon,
					User:           req.User,
				},
			},
		}

		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		res, errData := ResponseDeleteSuratKontrol(url, header, headers, request)
		log.Println("RESPONSE DELETE: ", res)
		log.Println("RESPONSE HEADER: ", errData)
		if errData != nil {
			responJson, err := json.Marshal(res)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "203",
						Message: err.Error(),
					},
				})
				return
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")

			uuid := uuid.New().String()
			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "BPJS-VClaim-RencanaKontrol",
				Header:          headerString,
				Method:          "DELETE",
				Url:             url,
				Request:         reqJson,
				Respon:          responJson,
				ResponCode:      res.MetaData.Code,
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}
			log.Printf("Error making external API request: %v", err)

			bpjs.HandleResponse(c, res)
			return
		}
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		uuid := uuid.New().String()
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "DELETE",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDDataSurKon,
			StatusSurKon:      0,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		bpjs.HandleResponse(c, res)
	} else {
		uuid := uuid.New().String()
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDDataSurKon,
			StatusSurKon:      0,
			UserUpdatedSurKon: req.User,
		}
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		reqJsoninternal, err := json.Marshal(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "Surat Kontrol Internal",
			Header:          headerString,
			Method:          "DELETE",
			Url:             url,
			Request:         reqJsoninternal,
			Respon:          reqJsoninternal,
			ResponCode:      "200",
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         "Berhasil Delete Surat Kontrol",
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		res := &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Hapus Data",
		}
		c.JSON(http.StatusOK, res)
		return
	}
}
func DeleteSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("DELETE_SURAT_KONTROL")
	url := baseUrl + endpoint + param

	var req sk.ReqDeleteRencanaKontrol

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	reqJson, err := json.Marshal(req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("REQUEST: ", req)

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	if req.TipeSurKon != "1" {
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDDataSurKon,
			StatusSurKon:      0,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		res := &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Hapus Data",
		}
		c.JSON(http.StatusOK, res)
		return
	}

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")
	request := &sk.RequestHeaderRencanaKontrol{
		Request: &sk.TSuratKontrol{
			RequestDelete: sk.RequestDeleteRencanaKontrol{
				NoSuratKontrol: req.NomorSurKon,
				User:           req.User,
			},
		},
	}

	logTimeStart := time.Now().Format("2006-01-02 15:04:05")
	res, err := ResponseDeleteSuratKontrol(url, header, headers, request)
	if err != nil {
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		uuid := uuid.New().String()
		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol",
			Header:          headerString,
			Method:          "DELETE",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, err)
		return
	}
	responJson, err := json.Marshal(res)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusPreconditionFailed, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}
	logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
	uuid := uuid.New().String()
	reqInsertLog := &logapi.DataLogAPI{
		ID:              uuid,
		DateCreated:     logTimeEnd,
		UserAgent:       req.User,
		IP:              c.ClientIP(),
		Parameter:       "BPJS-VClaim-RencanaKontrol",
		Header:          headerString,
		Method:          "DELETE",
		Url:             url,
		Request:         reqJson,
		Respon:          responJson,
		ResponCode:      res.MetaData.Code,
		ResponTimeStart: logTimeStart,
		ResponTimeEnd:   logTimeEnd,
		Comment:         res.MetaData.Message,
	}

	err = log_api.InsertLogAPI(reqInsertLog)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	reqUpdate := &sk.DataSuratKontrol{
		DateUpdated:       timeNow,
		ID:                req.IDDataSurKon,
		StatusSurKon:      0,
		UserUpdatedSurKon: req.User,
	}

	err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}
	c.JSON(http.StatusOK, res)
}

func GetNomorSuratKontrol(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("GET_NOMOR_SURAT_KONTROL")
	noSurat := c.Param("noSuratKontrol")
	url := baseUrl + endpoint + param + noSurat

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	res, err := ResponseGetNomorSuratKontrol(url, header, headers)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, res)
}

func GetSuratKontrolBySEP(c *gin.Context) {
	baseUrl := os.Getenv("BASEURL_BPJS")
	endpoint := os.Getenv("SURAT_KONTROL_RS")
	param := os.Getenv("GET_SURAT_KONTROL_SEP")
	noSEP := c.Param("noSEP")
	url := baseUrl + endpoint + param + noSEP

	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,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	log.Println("Headers : ", headers)

	res, err := ResponseGetSuratKontrolBySEP(url, header, headers)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		c.JSON(http.StatusInternalServerError, err)
		return
	}
	log.Println(res.Response.NoSEP)

	c.JSON(http.StatusOK, res)
}

func GetDataSurKon(c *gin.Context) {
	offset := c.Param("offset")
	limit := c.Param("limit")
	data, err := suratkontrol.GetDataSuratKontrol(offset, limit)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}
	var resSurKon []*sk.ResponseGetDataSuratKontrol
	for _, v := range data {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkapDokter + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		dateCetakSurkon, _ := time.Parse(time.RFC3339, v.TglCetakSurKon)
		dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
		dateRencanaSurkon, _ := time.Parse(time.RFC3339, v.TglRencanaKontrol)
		dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
		resSurKon = append(resSurKon, &sk.ResponseGetDataSuratKontrol{
			IDDataSurKon:      v.IDDataSurKon,
			IDXDaftar:         v.IDXDaftar,
			TglCetakSurKon:    dateCetakSurkonString,
			TglRencanaKontrol: dateRencanaSurkonString,
			NomorSurKon:       v.NomorSurKon,
			PoliAsal:          v.PoliAsal,
			PoliTujuan:        v.PoliTujuan,
			NomorSEP:          v.NomorSEP,
			NamaPasien:        v.NamaPasien,
			NamaDokter:        namaLengkap,
			NomorKartu:        "",
			Subspesialis:      v.Subspesialis,
			KodePoli:          v.KodePoli,
			KodeDokter:        v.KodeDokter,
			IDDokter:          v.IDDokter,
			KodeDPJP:          v.KodeDPJP,
			NoRM:              v.NoRM,
			KodeDiagnosa:      v.KodeDiagnosa,
			NamaDiagnosa:      v.NamaDiagnosa,
			TipeSurKon:        v.TipeSurKon,
			TipeRawat:         v.TipeRawat,
		})
	}
	c.JSON(http.StatusOK, resSurKon)
}
func GetDataSurKonByID(c *gin.Context) {
	id := c.Param("idxdaftar")
	tipe := c.Param("tiperawat")
	var dataSurKon *sk.GetDataSuratKontrol
	dataSurKon, err := suratkontrol.GetDataSuratKontrolByIDTipe(id, tipe)
	if err != nil {
		if err.Error() == "Data tidak ada" {
			dataSurKon, err = suratkontrol.GetDataSuratKontrolByID(id)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusInternalServerError, &sk.MetadataString{
					Code:    "",
					Message: err.Error(),
				})
				return
			}
		} else {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "",
				Message: err.Error(),
			})
			return
		}
	}

	gelarDepan := utils.ReplaceGelar(dataSurKon.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(dataSurKon.GelarBelakang)
	namaLengkap := gelarDepan + " " + dataSurKon.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      dataSurKon.IDDataSurKon,
		IDXDaftar:         dataSurKon.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       dataSurKon.NomorSurKon,
		PoliAsal:          dataSurKon.PoliAsal,
		PoliTujuan:        dataSurKon.PoliTujuan,
		NomorSEP:          dataSurKon.NomorSEP,
		NamaPasien:        dataSurKon.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        "",
		Subspesialis:      dataSurKon.Subspesialis,
		KodePoli:          dataSurKon.KodePoli,
		KodeDokter:        dataSurKon.KodeDokter,
		IDPoli:            dataSurKon.IDPoli,
		IDDokter:          dataSurKon.IDDokter,
		KodeDPJP:          dataSurKon.KodeDPJP,
		NoRM:              dataSurKon.NoRM,
		KodeDiagnosa:      dataSurKon.KodeDiagnosa,
		NamaDiagnosa:      dataSurKon.NamaDiagnosa,
		TipeSurKon:        dataSurKon.TipeSurKon,
		User:              dataSurKon.User,
	}
	c.JSON(http.StatusOK, resSurKon)
}
func NewGetDataSurKonByID(c *gin.Context) {
	id := c.Param("idxdaftar")
	tipe := c.Param("tiperawat")
	var dataSurKon *sk.GetDataSuratKontrol
	dataSurKon, err := suratkontrol.GetDataSuratKontrolByIDTipe(id, tipe)
	if err != nil {
		if err.Error() == "Data tidak ada" {
			dataSurKon, err = suratkontrol.GetDataSuratKontrolByID(id)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Pasien Belum Di terbitkan Surat Kontrol",
				})
				return
			}
		} else {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}

	gelarDepan := utils.ReplaceGelar(dataSurKon.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(dataSurKon.GelarBelakang)
	namaLengkap := gelarDepan + " " + dataSurKon.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      dataSurKon.IDDataSurKon,
		IDXDaftar:         dataSurKon.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       dataSurKon.NomorSurKon,
		PoliAsal:          dataSurKon.PoliAsal,
		PoliTujuan:        dataSurKon.PoliTujuan,
		NomorSEP:          dataSurKon.NomorSEP,
		NamaPasien:        dataSurKon.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        "",
		Subspesialis:      dataSurKon.Subspesialis,
		KodePoli:          dataSurKon.KodePoli,
		KodeDokter:        dataSurKon.KodeDokter,
		IDPoli:            dataSurKon.IDPoli,
		IDDokter:          dataSurKon.IDDokter,
		KodeDPJP:          dataSurKon.KodeDPJP,
		NoRM:              dataSurKon.NoRM,
		KodeDiagnosa:      dataSurKon.KodeDiagnosa,
		NamaDiagnosa:      dataSurKon.NamaDiagnosa,
		KodeIcd:           dataSurKon.KodeIcd,
		Diagnosa:          dataSurKon.Diagnosa,
		TipeSurKon:        dataSurKon.TipeSurKon,
		User:              dataSurKon.User,
	}

	c.JSON(http.StatusOK, resSurKon)
}

func GetDataSurKonByNoSurkon(c *gin.Context) {
	id := c.Param("idxdaftar")
	nomor := c.Param("nomorsurkon")
	var dataSurKon *sk.GetDataSuratKontrol
	dataSurKon, err := suratkontrol.GetDataSuratKontrolByIDnomor(id, nomor)
	if err != nil {
		if err.Error() == "Data tidak ada" {
			dataSurKon, err = suratkontrol.GetDataSuratKontrolnomor(nomor)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Pasien Belum Di terbitkan Surat Kontrol",
				})
				return
			}
		} else {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}

	gelarDepan := utils.ReplaceGelar(dataSurKon.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(dataSurKon.GelarBelakang)
	namaLengkap := gelarDepan + " " + dataSurKon.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      dataSurKon.IDDataSurKon,
		IDXDaftar:         dataSurKon.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       dataSurKon.NomorSurKon,
		PoliAsal:          dataSurKon.PoliAsal,
		PoliTujuan:        dataSurKon.PoliTujuan,
		NomorSEP:          dataSurKon.NomorSEP,
		NamaPasien:        dataSurKon.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        dataSurKon.NomorKartu,
		Subspesialis:      dataSurKon.Subspesialis,
		KodePoli:          dataSurKon.KodePoli,
		KodeDokter:        dataSurKon.KodeDokter,
		IDPoli:            dataSurKon.IDPoli,
		IDDokter:          dataSurKon.IDDokter,
		KodeDPJP:          dataSurKon.KodeDPJP,
		NoRM:              dataSurKon.NoRM,
		KodeDiagnosa:      dataSurKon.KodeIcd,
		NamaDiagnosa:      dataSurKon.Diagnosa,
		TipeSurKon:        dataSurKon.TipeSurKon,
		User:              dataSurKon.User,
	}
	c.JSON(http.StatusOK, resSurKon)
}

func GetDataSurKonByIDSurkon(c *gin.Context) {
	id := c.Param("idxdaftar")
	idsurkon := c.Param("id")
	var dataSurKon *sk.GetDataSuratKontrol
	dataSurKon, err := suratkontrol.GetDataSuratKontrolByIDsrukon(id, idsurkon)
	if err != nil {
		if err.Error() == "Data tidak ada" {
			dataSurKon, err = suratkontrol.GetDataSuratKontrolidsurkon(idsurkon)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: "Pasien Belum Di terbitkan Surat Kontrol",
				})
				return
			}
		} else {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}

	gelarDepan := utils.ReplaceGelar(dataSurKon.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(dataSurKon.GelarBelakang)
	namaLengkap := gelarDepan + " " + dataSurKon.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, dataSurKon.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      dataSurKon.IDDataSurKon,
		IDXDaftar:         dataSurKon.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       dataSurKon.NomorSurKon,
		PoliAsal:          dataSurKon.PoliAsal,
		PoliTujuan:        dataSurKon.PoliTujuan,
		NomorSEP:          dataSurKon.NomorSEP,
		NamaPasien:        dataSurKon.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        dataSurKon.NomorKartu,
		Subspesialis:      dataSurKon.Subspesialis,
		KodePoli:          dataSurKon.KodePoli,
		KodeDokter:        dataSurKon.KodeDokter,
		IDPoli:            dataSurKon.IDPoli,
		IDDokter:          dataSurKon.IDDokter,
		KodeDPJP:          dataSurKon.KodeDPJP,
		NoRM:              dataSurKon.NoRM,
		KodeDiagnosa:      dataSurKon.KodeIcd,
		NamaDiagnosa:      dataSurKon.Diagnosa,
		TipeSurKon:        dataSurKon.TipeSurKon,
		User:              dataSurKon.User,
	}
	c.JSON(http.StatusOK, resSurKon)
}

func PrintSurKon(c *gin.Context) {
	id := c.Param("idxdaftar")
	data, err := suratkontrol.GetDataSuratKontrolByID(id)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}

	gelarDepan := utils.ReplaceGelar(data.GelarDepan)
	gelarBelakang := utils.ReplaceGelar(data.GelarBelakang)
	namaLengkap := gelarDepan + " " + data.NamaLengkapDokter + " " + gelarBelakang
	namaLengkap = strings.TrimPrefix(namaLengkap, " ")
	namaLengkap = strings.TrimSuffix(namaLengkap, " ")
	dateCetakSurkon, _ := time.Parse(time.RFC3339, data.TglCetakSurKon)
	dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
	dateRencanaSurkon, _ := time.Parse(time.RFC3339, data.TglRencanaKontrol)
	dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
	resSurKon := &sk.ResponseGetDataSuratKontrol{
		IDDataSurKon:      data.IDDataSurKon,
		IDXDaftar:         data.IDXDaftar,
		TglCetakSurKon:    dateCetakSurkonString,
		TglRencanaKontrol: dateRencanaSurkonString,
		NomorSurKon:       data.NomorSurKon,
		PoliAsal:          data.PoliAsal,
		PoliTujuan:        data.PoliTujuan,
		NomorSEP:          data.NomorSEP,
		NamaPasien:        data.NamaPasien,
		NamaDokter:        namaLengkap,
		NomorKartu:        "",
		Subspesialis:      data.Subspesialis,
	}
	log.Println("Data surkon", resSurKon)
	c.JSON(http.StatusOK, resSurKon)
}

func CariPasienTPP(c *gin.Context) {
	var req sk.RequestCariPasien

	err := c.ShouldBindJSON(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}

	log.Println("request :", req)

	query := ``
	var args []interface{}
	var argsCount []interface{}
	var data []*sk.GetDataSuratKontrol
	var count int
	if req.NoRM != "" {
		query += `and dkp2."NOMR" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.NoRM, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.NoRM, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	} else if req.NoSEP != "" {
		query += `and dkp2."Nomor_sep" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.NoSEP, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.NoSEP, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	} else if req.PoliKlinik != "" {
		query += `and ds."id" = ?`
		argsCount = append(argsCount, req.TipeSurKon, req.PoliKlinik, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.PoliKlinik, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	} else {
		argsCount = append(argsCount, req.TipeSurKon, req.TanggalAwal, req.TanggalAkhir)
		count, err = suratkontrol.CountDataSurKon(req, query, argsCount)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		args = append(args, req.TipeSurKon, req.TanggalAwal, req.TanggalAkhir, req.Offset, req.Limit)
		data, err = suratkontrol.SearchDataSurKon(req, query, args)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}
	var listData []*sk.ResponseGetDataSuratKontrol
	for _, v := range data {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaLengkapDokter + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		dateCetakSurkon, _ := time.Parse(time.RFC3339, v.TglCetakSurKon)
		dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
		dateRencanaSurkon, _ := time.Parse(time.RFC3339, v.TglRencanaKontrol)
		dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
		listData = append(listData, &sk.ResponseGetDataSuratKontrol{
			IDDataSurKon:      v.IDDataSurKon,
			IDXDaftar:         v.IDXDaftar,
			TglCetakSurKon:    dateCetakSurkonString,
			TglRencanaKontrol: dateRencanaSurkonString,
			NomorSurKon:       v.NomorSurKon,
			PoliAsal:          v.PoliAsal,
			PoliTujuan:        v.PoliTujuan,
			NomorSEP:          v.NomorSEP,
			NamaPasien:        v.NamaPasien,
			NamaDokter:        namaLengkap,
			NomorKartu:        "",
			Subspesialis:      v.Subspesialis,
			KodePoli:          v.KodePoli,
			KodeDokter:        v.KodeDokter,
			IDDokter:          v.IDDokter,
			KodeDPJP:          v.KodeDPJP,
			NoRM:              v.NoRM,
			KodeDiagnosa:      v.KodeDiagnosa,
			NamaDiagnosa:      v.NamaDiagnosa,
			TipeSurKon:        v.TipeSurKon,
			TipeRawat:         v.TipeRawat,
		})
	}

	resSurKon := &sk.ResponseCariDataSuratKontrol{
		JumlahData:           count,
		ListDataSuratKontrol: listData,
	}
	c.JSON(http.StatusOK, resSurKon)
}

func GethistoribyNorm(c *gin.Context) {
	norm := c.Param("norm")
	offset := c.Param("offset")
	limit := c.Param("limit")

	data, err := suratkontrol.Getdatahistori(norm, offset, limit)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}

	var resHisSurKon []*sk.Dataresponse
	for _, v := range data {
		gelarDepan := utils.ReplaceGelar(v.GelarDepan)
		gelarBelakang := utils.ReplaceGelar(v.GelarBelakang)
		namaLengkap := gelarDepan + " " + v.NamaDokter + " " + gelarBelakang
		namaLengkap = strings.TrimPrefix(namaLengkap, " ")
		namaLengkap = strings.TrimSuffix(namaLengkap, " ")
		dateCetakSurkon, _ := time.Parse(time.RFC3339, v.TanggalCetak)
		dateCetakSurkonString := dateCetakSurkon.Format("2006-01-02")
		dateRencanaSurkon, _ := time.Parse(time.RFC3339, v.TanggalRencana)
		dateRencanaSurkonString := dateRencanaSurkon.Format("2006-01-02")
		resHisSurKon = append(resHisSurKon, &sk.Dataresponse{
			NamaPasien:        v.NamaPasien,
			NoSEP:             v.NoSEP,
			IdSurkon:          v.IdSurkon,
			Idxdaftar:         v.Idxdaftar,
			NomorSuratkontrol: v.NomorSuratkontrol,
			TanggalRencana:    dateRencanaSurkonString,
			TanggalCetak:      dateCetakSurkonString,
			Spesialis:         v.Spesialis,
			Subspesialis:      v.Subspesialis,
			NamaLengkap:       namaLengkap,
			Tiperawat:         v.Tiperawat,
			TipeSurkon:        v.TipeSurkon,
			UserCreate:        v.UserCreate,
			UserUpdate:        v.UserUpdate,
			Status:            v.Status,
		})
	}
	c.JSON(http.StatusOK, resHisSurKon)
}

func InsertSpri(c *gin.Context) {
	//baseUrl := os.Getenv("BASEURL_BPJS")
	//endpoint := os.Getenv("SURAT_KONTROL_RS")
	baseUrl := os.Getenv("BASEURL_BPJS_DEV")
	endpoint := os.Getenv("VCLAIM_RS_DEV")
	param := os.Getenv("INSERT_SPRI")
	url := baseUrl + endpoint + param
	log.Println(url)
	timeNow := time.Now().Format("2006-01-02 15:04:05")

	conf := config.ConfigBpjs{}

	header := cfg.SetHeaderDev(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")
	log.Println(headerString)

	var req sk.RequestInsertSPRI

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
			MetaData: sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			},
		})
		return
	}

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}

	var idRuangan int
	if kunjunganPasien.Ruangan != 0 {
		idRuangan = kunjunganPasien.Ruangan
	} else {
		idRuangan, err = lokasiruang.GetDaftarLokasiRuang(req.Ruangan)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
	}
	idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}
	uuid := uuid.New().String()
	if req.TipeSurKon == "2" || req.TipeSurKon == "5" {
		reqJson, err := json.Marshal(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}
		reqSPRI := &sk.RequestHeaderRencanaKontrol{
			Request: &sk.ReqInsertSPRIbpjs{
				NoKartu:           req.NoKartu,
				KodeDokter:        req.KodeHFIS,
				PoliKontrol:       req.KodePoli,
				TglRencanaKontrol: req.TglRencanaKontrol,
				User:              req.User,
			},
		}
		log.Println(reqSPRI)
		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		res, errData := PostDataSPRI(url, header, headers, reqSPRI)
		log.Println("responnya : ", res)
		log.Println("errornya : ", errData)
		log.Println(logTimeStart)
		if errData != nil {
			log.Println(errData)
			responJson, err := json.Marshal(res)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.ResponseInsertSuratKontrol{
					MetaData: sk.MetadataString{
						Code:    "201",
						Message: err.Error(),
					},
				})
				return
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "BPJS-VClaim-RencanaKontrol/InsertSPRI",
				Header:          headerString,
				Method:          "POST",
				Url:             url,
				Request:         reqJson,
				Respon:          responJson,
				ResponCode:      res.MetaData.Code,
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}
			bpjs.HandleResponseSPRI(c, res)
			return
		}
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusOK, &sk.ResponseInsertSuratKontrol{
				MetaData: sk.MetadataString{
					Code:    "203",
					Message: err.Error(),
				},
			})
			return
		}

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NomorSurKon:       res.Response.NoSPRI,
			NomorKartu:        res.Response.NoKartu,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     idRuangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // First Insert status always set to 1
			UserCreatedSurKon: req.User,
			TipeSurKon:        "5",
			TipeRawat:         "RI",
		}
		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol/InsertSPRI",
			Header:          headerString,
			Method:          "POST",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		response := &sk.ResponseInsertSuratKontrolSPRI{
			MetaData: res.MetaData,
			Response: sk.ResponseDataSPRI{
				NoSPRI:            res.Response.NoSPRI,
				TglRencanaKontrol: res.Response.TglRencanaKontrol,
				NamaDokter:        res.Response.NamaDokter,
				NoKartu:           res.Response.NoKartu,
				Nama:              res.Response.Nama,
				Kelamin:           res.Response.Kelamin,
				TglLahir:          res.Response.TglLahir,
				NamaDiagnosa:      res.Response.NamaDiagnosa,
			},
		}
		log.Println("Response: ", response)
		c.JSON(http.StatusOK, response)
	} else {

	}
}

func UpdateSpri(c *gin.Context) {
	//baseUrl := os.Getenv("BASEURL_BPJS")
	//endpoint := os.Getenv("SURAT_KONTROL_RS")

	baseUrl := os.Getenv("BASEURL_BPJS_DEV")
	endpoint := os.Getenv("VCLAIM_RS_DEV")
	param := os.Getenv("UPDATE_SPRI")
	url := baseUrl + endpoint + param

	conf := config.ConfigBpjs{}

	header := cfg.SetHeaderDev(false, conf)

	headers := map[string]string{
		"X-cons-id":    header.ConsID,
		"X-timestamp":  header.TimeStamp,
		"X-signature":  header.XSignature,
		"user_key":     header.UserKey,
		"Content-Type": "Application/x-www-form-urlencoded",
	}
	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(), "; ")

	var req sk.RequestUpdateRencanaKontrolspri

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "203",
			Message: err.Error(),
		})
		return
	}

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	kunjunganPasien, err := suratkontrol.GetDataKunjunganPasien(req.IDXDaftar)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusCreated, &sk.MetadataString{
			Code:    "201",
			Message: err.Error(),
		})
		return
	}

	uuid := uuid.New().String()
	if req.TipeSurKon == "5" {
		reqJson, err := json.Marshal(req)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusInternalServerError, &sk.MetadataString{
				Code:    "203",
				Message: err.Error(),
			})
			return
		}
		log.Println("reqJson : ", string(reqJson))

		reqSuratKontrolspri := &sk.RequestHeaderRencanaKontrol{
			Request: &sk.ReqUpdateRencanaKontrolspri{
				NoSPRI:            req.NoSPRI,
				KodeDokter:        req.KodeHFIS,
				PoliKontrol:       req.KodePoli,
				TglRencanaKontrol: req.TglRencanaKontrol,
				User:              req.User,
			},
		}
		log.Println("reqJson : ", reqSuratKontrolspri)

		logTimeStart := time.Now().Format("2006-01-02 15:04:05")
		res, errData := ResponseUpdateSuratKontrolSPRI(url, header, headers, reqSuratKontrolspri)
		log.Println("error nya", errData)
		log.Println("ResponseUpdateSuratKontrol: ", res)
		if errData != nil {
			responJson, err := json.Marshal(res)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusInternalServerError, &sk.MetadataString{
					Code:    res.MetaData.Code,
					Message: res.MetaData.Message,
				})
				return
			}
			logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
			if res.MetaData.Code == "504" {
				log.Println(err)
				c.JSON(http.StatusGatewayTimeout, res.MetaData)
				return
			}

			reqInsertLog := &logapi.DataLogAPI{
				ID:              uuid,
				DateCreated:     logTimeEnd,
				UserAgent:       req.User,
				IP:              c.ClientIP(),
				Parameter:       "BPJS-VClaim-RencanaKontrol",
				Header:          headerString,
				Method:          "PUT",
				Url:             url,
				Request:         reqJson,
				Respon:          responJson,
				ResponCode:      res.MetaData.Code,
				ResponTimeStart: logTimeStart,
				ResponTimeEnd:   logTimeEnd,
				Comment:         res.MetaData.Message,
			}

			err = log_api.InsertLogAPI(reqInsertLog)
			if err != nil {
				log.Println(err)
				c.JSON(http.StatusCreated, &sk.MetadataString{
					Code:    "201",
					Message: err.Error(),
				})
				return
			}
			log.Println(err)

			bpjs.HandleResponseSPRI(c, res)

			return
		}
		responJson, err := json.Marshal(res)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		logTimeEnd := time.Now().Format("2006-01-02 15:04:05")
		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDSurKon,
			StatusSurKon:      2,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		UserCreated, err := suratkontrol.GetUserCreated(req.IDSurKon)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
		}
		idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
		}

		reqInsert := &sk.DataSuratKontrol{
			ID:                uuid,
			DateCreated:       UserCreated.DataCreate,
			DateUpdated:       timeNow,
			TglCetakSurKon:    timeNow,
			TglRencanaKontrol: res.Response.TglRencanaKontrol,
			NomorSurKon:       res.Response.NoSPRI,
			NomorKartu:        res.Response.NoKartu,
			KunjunganPasien:   kunjunganPasien.ID,
			RuanganSurKon:     kunjunganPasien.Ruangan,
			DPJPSurKon:        idDokter,
			StatusSurKon:      1, // Insert status always set to 1
			TipeSurKon:        req.TipeSurKon,
			TipeRawat:         req.TipeRawat,
			UserCreatedSurKon: UserCreated.UserCreate,
			UserUpdatedSurKon: req.User,
		}

		if reqInsert.DPJPSurKon == "" {
			reqInsert.DPJPSurKon = kunjunganPasien.DPJP
		}

		err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}

		reqInsertLog := &logapi.DataLogAPI{
			ID:              uuid,
			DateCreated:     logTimeEnd,
			UserAgent:       req.User,
			IP:              c.ClientIP(),
			Parameter:       "BPJS-VClaim-RencanaKontrol/UpdateSPRI",
			Header:          headerString,
			Method:          "PUT",
			Url:             url,
			Request:         reqJson,
			Respon:          responJson,
			ResponCode:      res.MetaData.Code,
			ResponTimeStart: logTimeStart,
			ResponTimeEnd:   logTimeEnd,
			Comment:         res.MetaData.Message,
		}
		log.Println("MASUK LOG DISINI: ", reqInsertLog)

		err = log_api.InsertLogAPI(reqInsertLog)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		response := &sk.ResponseInsertSuratKontrolSPRI{
			MetaData: res.MetaData,
			Response: sk.ResponseDataSPRI{
				NoSPRI:            res.Response.NoSPRI,
				TglRencanaKontrol: res.Response.TglRencanaKontrol,
				NamaDokter:        res.Response.NamaDokter,
				NoKartu:           res.Response.NoKartu,
				Nama:              res.Response.Nama,
				Kelamin:           res.Response.Kelamin,
				TglLahir:          res.Response.TglLahir,
				NamaDiagnosa:      res.Response.NamaDiagnosa,
			},
		}
		log.Println("Response: ", response)
		c.JSON(http.StatusOK, response)

	} else {
		//dataSurkon, err := suratkontrol.GetNomorSurKon(kunjunganPasien.ID)
		//if err != nil {
		//	log.Println(err)
		//	c.JSON(http.StatusCreated, &sk.MetadataString{
		//		Code:    "201",
		//		Message: err.Error(),
		//	})
		//	return
		//}
		//
		//reqUpdate := &sk.DataSuratKontrol{
		//	DateUpdated:       timeNow,
		//	ID:                req.IDSurKon,
		//	StatusSurKon:      2,
		//	UserUpdatedSurKon: req.User,
		//}
		//
		//err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		//if err != nil {
		//	log.Println(err)
		//	c.JSON(http.StatusCreated, &sk.MetadataString{
		//		Code:    "201",
		//		Message: err.Error(),
		//	})
		//	return
		//}
		//UserCreated, err := suratkontrol.GetUserCreated(req.IDSurKon)
		//if err != nil {
		//	log.Println(err)
		//	c.JSON(http.StatusCreated, &sk.MetadataString{
		//		Code:    "201",
		//		Message: err.Error(),
		//	})
		//}
		//idDokter, err := suratkontrol.GetIdDokterByHFIS(req.KodeHFIS)
		//if err != nil {
		//	log.Println(err)
		//	c.JSON(http.StatusCreated, &sk.MetadataString{
		//		Code:    "201",
		//		Message: err.Error(),
		//	})
		//}
		//reqInsert := &sk.DataSuratKontrol{
		//	ID:                uuid,
		//	DateCreated:       timeNow,
		//	TglCetakSurKon:    timeNow,
		//	TglRencanaKontrol: req.TglRencanaKontrol,
		//	NomorSurKon:       dataSurkon, //TODO How to get Nomor SurKon
		//	KunjunganPasien:   kunjunganPasien.ID,
		//	RuanganSurKon:     kunjunganPasien.Ruangan,
		//	DPJPSurKon:        idDokter,
		//	StatusSurKon:      1, // First Insert status always set to 1
		//	TipeSurKon:        req.TipeSurKon,
		//	UserCreatedSurKon: UserCreated,
		//	UserUpdatedSurKon: req.User,
		//	TipeRawat:         req.TipeRawat,
		//}
		//err = suratkontrol.InsertDataSuratKontrol(reqInsert)
		//if err != nil {
		//	log.Println(err)
		//	c.JSON(http.StatusCreated, &sk.MetadataString{
		//		Code:    "201",
		//		Message: err.Error(),
		//	})
		//	return
		//}
		//
		//c.JSON(http.StatusOK, &sk.MetadataString{
		//	Code:    "200",
		//	Message: "Berhasil Update Surat Kontrol",
		//})
		//return
	}
}

func DeleteSpri(c *gin.Context) {

	var req sk.ReqDeleteRencanaKontrolSPRI

	err := c.Bind(&req)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusInternalServerError, &sk.MetadataString{
			Code:    "",
			Message: err.Error(),
		})
		return
	}

	log.Println("REQUEST: ", req)

	timeNow := time.Now().Format("2006-01-02 15:04:05")

	if req.TipeSurKon == "5" {

		reqUpdate := &sk.DataSuratKontrol{
			DateUpdated:       timeNow,
			ID:                req.IDDataSurKon,
			StatusSurKon:      0,
			UserUpdatedSurKon: req.User,
		}

		err = suratkontrol.UpdateDataSuratKontrol(reqUpdate)
		if err != nil {
			log.Println(err)
			c.JSON(http.StatusCreated, &sk.MetadataString{
				Code:    "201",
				Message: err.Error(),
			})
			return
		}
		res := &sk.MetadataString{
			Code:    "200",
			Message: "Berhasil Hapus Data",
		}
		c.JSON(http.StatusOK, res)
		return
	}
}