package redis

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"satusehat-rssa/internal/constant"
	"satusehat-rssa/internal/model"
	"strings"

	"github.com/redis/go-redis/v9"
)

type RedisAkses struct {
	akses *model.Akses
}

type RedisInterface interface {
	GetOrCreateTokenSS(ctx context.Context, nik string) (string, error)
}

func NewRedisAuth(akses *model.Akses) RedisInterface {
	return &RedisAkses{
		akses: akses,
	}

}

func (s *RedisAkses) GetOrCreateTokenSS(ctx context.Context, nik string) (string, error) {
	const redisKey = "token-ss"
	var code string

	// 1️⃣ ambil dari redis
	token, err := s.akses.Redis.Get(ctx, redisKey).Result()
	if err != nil && err != redis.Nil {
		return "", err
	}

	// 2️⃣ optional validation: only when nik provided, verify token masih valid
	if token != "" && nik != "" {
		code, err = s.GetPatientByNIK(nik, token)
		if err != nil {
			return "", err
		}
	}

	if code == "invalid-access-token" || token == "" {
		// hapus token dari redis
		if err := s.akses.Redis.Del(ctx, redisKey).Err(); err != nil {
			return "", err
		}
		// 3️⃣ generate token baru
		oauth := model.OauthRequest{
			ClientId:     s.akses.ClientId,
			ClientSecret: s.akses.ClientSecret,
		}

		obj_token, err := s.GenerateToken(oauth)
		if err != nil {
			return "", err
		}
		if obj_token == nil || obj_token.AccessToken == "" {
			return "", errors.New(constant.ErrGenerateToken)
		}

		// 4️⃣ simpan ke redis (opsional TTL)
		if err := s.akses.Redis.Set(ctx, redisKey, obj_token.AccessToken, 0).Err(); err != nil {
			return "", err
		}

		return obj_token.AccessToken, nil
	}
	return token, nil
}

func (o *RedisAkses) GenerateToken(req model.OauthRequest) (*model.OauthResponse, error) {
	var (
		data *model.OauthResponse
	)
	url := o.akses.AuthUrl + "/accesstoken?grant_type=client_credentials"
	method := "POST"

	req_data := "client_id=" + req.ClientId + "&client_secret=" + req.ClientSecret
	payload := strings.NewReader(req_data)

	client := &http.Client{}
	request, err := http.NewRequest(method, url, payload)

	if err != nil {
		return nil, err
	}
	request.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}
	return data, nil
}

func (p *RedisAkses) GetPatientByNIK(nik string, token string) (string, error) {
	var (
		data *map[string]interface{}
	)
	url := p.akses.BaseUrl + "/Patient?identifier=https://fhir.kemkes.go.id/id/nik|" + nik
	method := "GET"
	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return "", err
	}
	if token != "" {
		request.Header.Add("Authorization", "Bearer "+token)
	} else {
		return "", errors.New(constant.ErrGenerateToken)
	}

	request.Header.Set("Content-Type", constant.ContentTypeFHIRJSON)
	request.Header.Set("Accept", constant.ContentTypeFHIRJSON)

	res, err := client.Do(request)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return "", err
	}

	// Cek jika response adalah OperationOutcome dan ambil code
	if data != nil {
		if rt, ok := (*data)["resourceType"].(string); ok && rt == "OperationOutcome" {
			if issues, ok := (*data)["issue"].([]interface{}); ok && len(issues) > 0 {
				if issueMap, ok := issues[0].(map[string]interface{}); ok {
					if code, ok := issueMap["code"].(string); ok {
						return code, nil
					}
				}
			}
		}
	}

	dataJSON, _ := json.Marshal(data)
	return string(dataJSON), nil
}