package suratkontrol

import (
	"bridging-rssa/docs"
	suratkontrol "bridging-rssa/models/bpjs/surat_kontrol"
	"bridging-rssa/models/config"
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"strings"
)

func PostDataSPRI(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Responsespri, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("POST", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}

	responses := &suratkontrol.Responsespri{}
	response, err := client.Do(req)
	if err != nil {
		responses.MetaData.Code = "203"
		responses.MetaData.Message = err.Error()
		log.Printf("Error making external API request: %v", err)
		log.Println("responses: ", responses)
		return responses, err
	}
	log.Println("RESPONSE: ", response)

	if response.StatusCode == http.StatusGatewayTimeout { // 504
		errMsg := errors.New("Koneksi BPJS Terputus, Silahkan Coba Lagi")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "504"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	log.Println("Res:", string(res))

	var resSuratKontrolRaw suratkontrol.ResponseRaw
	err = json.Unmarshal([]byte(string(res)), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	log.Println("ResponseRaw : ", resSuratKontrolRaw)

	if resSuratKontrolRaw.MetaData.Code != "200" {
		if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Nomor SEP Sudah pernah digunakan!." {
			message := "Gagal simpan! Nomor SEP pernah diterbitkan Surat Kontrol!."
			resSuratKontrolRaw.MetaData.Message = message
			log.Println("masuk sini kan")
		} else if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Poli Tujuan Kontrol tidak sama dengan Poli Asal Rujukan Awal." {
			message := "Surat kontrol gagal diterbitkan, pastikan klinik tujuan sama dengan klinik asal pada rujukan awal"
			resSuratKontrolRaw.MetaData.Message = message
		}
		log.Printf("error : %v", resSuratKontrolRaw.MetaData.Message)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol suratkontrol.ResponseSuratKontrolSPRI

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Responsespri{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: resSuratKontrol,
	}

	return responses, nil
}
func PostData(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("POST", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}

	responses := &suratkontrol.Response{}
	response, err := client.Do(req)
	if err != nil {
		responses.MetaData.Code = "203"
		responses.MetaData.Message = err.Error()
		log.Printf("Error making external API request: %v", err)
		log.Println("responses: ", responses)
		return responses, err
	}
	log.Println("RESPONSE: ", response)

	if response.StatusCode == http.StatusGatewayTimeout { // 504
		errMsg := errors.New("Koneksi BPJS Terputus, Silahkan Coba Lagi")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "504"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	if response.StatusCode == http.StatusInternalServerError { // 500
		errMsg := errors.New("Server BPJS Down")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "500"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	log.Println("Res:", string(res))

	var resSuratKontrolRaw suratkontrol.ResponseRaw
	err = json.Unmarshal([]byte(string(res)), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	log.Println("ResponseRaw : ", resSuratKontrolRaw)

	if resSuratKontrolRaw.MetaData.Code != "200" {
		if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Nomor SEP Sudah pernah digunakan!." {
			message := "Gagal simpan! Nomor SEP pernah diterbitkan Surat Kontrol!."
			resSuratKontrolRaw.MetaData.Message = message
			log.Println("masuk sini kan")
		} else if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Poli Tujuan Kontrol tidak sama dengan Poli Asal Rujukan Awal." {
			message := "Surat kontrol gagal diterbitkan, pastikan klinik tujuan sama dengan klinik asal pada rujukan awal"
			resSuratKontrolRaw.MetaData.Message = message
		}
		log.Printf("error : %v", resSuratKontrolRaw.MetaData.Message)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol suratkontrol.ResponseSuratKontrol

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: resSuratKontrol,
	}

	return responses, nil
}

func ResponseUpdateSuratKontrol(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("PUT", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	responses := &suratkontrol.Response{}
	response, err := client.Do(req)
	if err != nil {
		responses.MetaData.Code = "504"
		responses.MetaData.Message = err.Error()
		log.Println("responses: ", responses)
		log.Printf("Error making external API request: %v", err)
		return responses, err
	}
	log.Println("RESPONSE: ", response)

	if response.StatusCode == http.StatusGatewayTimeout { // 504
		errMsg := errors.New("Koneksi BPJS Terputus, Silahkan Coba Lagi")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "504"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, err
	}

	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	var resSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(res), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	if resSuratKontrolRaw.MetaData.Code != "200" {
		if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Nomor SEP Sudah pernah digunakan!." {
			message := "Gagal simpan! Nomor SEP pernah diterbitkan Surat Kontrol!."
			resSuratKontrolRaw.MetaData.Message = message
			log.Println("masuk sini kan")
		} else if strings.Contains(strings.ToLower(resSuratKontrolRaw.MetaData.Message), "gagal simpan") {
			message := "Surat kontrol gagal diterbitkan, pastikan klinik tujuan sama dengan klinik asal pada rujukan awal"
			resSuratKontrolRaw.MetaData.Message = message
		}
		log.Printf("error : %v", resSuratKontrolRaw.MetaData.Message)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol *suratkontrol.ResponseSuratKontrol

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: *resSuratKontrol,
	}

	return responses, nil
}
func ResponseUpdateSuratKontrolSPRI(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Responsespri, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("PUT", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	responses := &suratkontrol.Responsespri{}
	response, err := client.Do(req)
	if err != nil {
		responses.MetaData.Code = "504"
		responses.MetaData.Message = err.Error()
		log.Println("responses: ", responses)
		log.Printf("Error making external API request: %v", err)
		return responses, err
	}
	log.Println("RESPONSE: ", response)

	if response.StatusCode == http.StatusGatewayTimeout { // 504
		errMsg := errors.New("Koneksi BPJS Terputus, Silahkan Coba Lagi")
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = "504"
		responses.MetaData.Message = errMsg.Error()
		log.Println("responses: ", responses)
		return responses, err
	}

	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	var resSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(res), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	if resSuratKontrolRaw.MetaData.Code != "200" {
		if resSuratKontrolRaw.MetaData.Message == "Gagal simpan! Nomor SEP Sudah pernah digunakan!." {
			message := "Gagal simpan! Nomor SEP pernah diterbitkan Surat Kontrol!."
			resSuratKontrolRaw.MetaData.Message = message
			log.Println("masuk sini kan")
		} else if strings.Contains(strings.ToLower(resSuratKontrolRaw.MetaData.Message), "gagal simpan") {
			message := "Surat kontrol gagal diterbitkan, pastikan klinik tujuan sama dengan klinik asal pada rujukan awal"
			resSuratKontrolRaw.MetaData.Message = message
		}
		log.Printf("error : %v", resSuratKontrolRaw.MetaData.Message)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		log.Println("res: ", dataResp)
		return nil, err
	}

	var resSuratKontrol *suratkontrol.ResponseSuratKontrolSPRI

	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &resSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.Responsespri{
		MetaData: resSuratKontrolRaw.MetaData,
		Response: *resSuratKontrol,
	}

	return responses, nil
}
func ResponseDeleteSuratKontrol(url string, header *config.Header, headers map[string]string, request *suratkontrol.RequestHeaderRencanaKontrol) (*suratkontrol.Response, error) {
	log.Println("URL", url)

	reqMarshall, err := json.Marshal(request)
	if err != nil {
		log.Printf("Error json marshal: %v", err)
	}

	log.Println("REQUEST: ", string(reqMarshall))

	req, err := http.NewRequest("DELETE", url, bytes.NewReader(reqMarshall))
	if err != nil {
		log.Printf("Error creating request: %v", err)
		return nil, err
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
		return nil, err
	}
	log.Println("RESPONSE: ", response)

	res, err := io.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	var resSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(res), &resSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	responses := &suratkontrol.Response{}
	if resSuratKontrolRaw.MetaData.Code != "200" {
		errMsg := errors.New(resSuratKontrolRaw.MetaData.Message)
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = resSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resSuratKontrolRaw.MetaData.Message
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	responses = &suratkontrol.Response{
		MetaData: resSuratKontrolRaw.MetaData,
	}

	log.Println("res: ", responses)

	return responses, nil
}

func ResponseGetNomorSuratKontrol(url string, header *config.Header, headers map[string]string) (*suratkontrol.ResponseGetSuratKontrol, error) {
	log.Println("URL", url)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Printf("Error creating request: %v", err)
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
	}
	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		log.Println(err)
	}
	log.Println("res: ", string(res))

	var resNoSuratKontrolRaw suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(string(res)), &resNoSuratKontrolRaw)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	responses := &suratkontrol.ResponseGetSuratKontrol{}
	if resNoSuratKontrolRaw.MetaData.Code != "200" {
		errMsg := errors.New(resNoSuratKontrolRaw.MetaData.Message)
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = resNoSuratKontrolRaw.MetaData.Code
		responses.MetaData.Message = resNoSuratKontrolRaw.MetaData.Message
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resNoSuratKontrolRaw.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		return nil, err
	}

	log.Println("dataresp: ", dataResp)

	var responseNoSuratKontrol suratkontrol.ResponseNomorSuratKontrol
	err = json.Unmarshal([]byte(dataResp), &responseNoSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	responses = &suratkontrol.ResponseGetSuratKontrol{
		MetaData: resNoSuratKontrolRaw.MetaData,
		Response: responseNoSuratKontrol,
	}
	log.Println("res: ", responses)

	return responses, nil
}

func ResponseGetSuratKontrolBySEP(url string, header *config.Header, headers map[string]string) (*suratkontrol.ResponseGetSuratKontrolBySEP, error) {
	log.Println("URL", url)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Printf("Error creating request: %v", err)
	}

	for key, value := range headers {
		req.Header.Set(key, value)
	}

	log.Println("REQ", req.Header)
	client := http.Client{}
	response, err := client.Do(req)
	if err != nil {
		log.Printf("Error making external API request: %v", err)
	}
	log.Println("RESPONSE: ", response)

	key := header.ConsID + header.SecretKey + header.TimeStamp
	res, err := io.ReadAll(response.Body)
	if err != nil {
		log.Println(err)
	}

	var resSurKonSEP suratkontrol.ResponseRawUpper
	err = json.Unmarshal([]byte(string(res)), &resSurKonSEP)
	if err != nil {
		log.Printf("Error Unmarshaling: %v", err)
		return nil, err
	}

	responses := &suratkontrol.ResponseGetSuratKontrolBySEP{}
	if resSurKonSEP.MetaData.Code != "200" {
		errMsg := errors.New(resSurKonSEP.MetaData.Message)
		log.Printf("error : %v", errMsg)
		responses.MetaData.Code = resSurKonSEP.MetaData.Code
		responses.MetaData.Message = resSurKonSEP.MetaData.Message
		log.Println("responses: ", responses)
		return responses, errMsg
	}

	dataResp, err := docs.StringDecrypt(key, resSurKonSEP.Response)
	if err != nil {
		log.Printf("Error Decrypt: %v", err)
		return nil, err
	}

	var responseNoSuratKontrol suratkontrol.ResponseSuratKontrolBySEP
	log.Println("dataresp: ", dataResp)

	err = json.Unmarshal([]byte(dataResp), &responseNoSuratKontrol)
	if err != nil {
		log.Printf("Error Decode: %v", err)
		return nil, err
	}

	log.Println("res: ", resSurKonSEP)

	responses = &suratkontrol.ResponseGetSuratKontrolBySEP{
		MetaData: resSurKonSEP.MetaData,
		Response: responseNoSuratKontrol,
	}

	return responses, nil
}