package main

import (
	"context"
	"encoding/base64"
	"os"

	"certmanager/pkg/client"
	"certmanager/pkg/cmctl"
)

func (util *Util) CreateIssuerPair(ctx context.Context) (*cmctl.CreateIssuerPairResult, error) {
	var err error
	res := &cmctl.CreateIssuerPairResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	params := &cmctl.CreateIssuerPairParams{
		IssuerOrganizationName:       util.issuerOrganizationName,
		IssuerOrganizationalUnitName: util.issuerOrganizationalUnitName,
		IssuerCommonName:             util.issuerCommonName,
		SignerID:                     util.signerID,
		EncodingKey:                  util.encodingKey,
	}
	res, err = cli.CreateIssuerPair(ctx, params)
	if err != nil {
		return res, err
	}
	certPEM, err := base64.StdEncoding.DecodeString(res.Certificate)
	if err != nil {
		return res, err
	}
	res.Certificate = string(certPEM)
	for i, cert := range res.SignerCertificates {
		caPEM, err := base64.StdEncoding.DecodeString(cert)
		if err != nil {
			return res, err
		}
		res.SignerCertificates[i] = string(caPEM)
	}
	return res, err
}

func (util *Util) ImportIssuerPair(ctx context.Context) (*cmctl.ImportIssuerPairResult, error) {
	var err error
	res := &cmctl.ImportIssuerPairResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	certBytes, err := os.ReadFile(util.certFilename)
	if err != nil {
		return res, err
	}
	cert := base64.StdEncoding.EncodeToString(certBytes)
	keyBytes, err := os.ReadFile(util.certFilename)
	if err != nil {
		return res, err
	}
	key := base64.StdEncoding.EncodeToString(keyBytes)

	params := &cmctl.ImportIssuerPairParams{
		Certificate: cert,
		Key:         key,
	}
	res, err = cli.ImportIssuerPair(ctx, params)
	if err != nil {
		return res, err
	}
	return res, err
}

func (util *Util) RevokeIssuerPair(ctx context.Context) (*cmctl.RevokeIssuerPairResult, error) {
	var err error
	res := &cmctl.RevokeIssuerPairResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	params := &cmctl.RevokeIssuerPairParams{
		IssuerID:   util.issuerID,
		IssuerName: util.issuerName,
	}
	res, err = cli.RevokeIssuerPair(ctx, params)
	if err != nil {
		return res, err
	}
	return res, err
}

func (util *Util) UnrevokeIssuerPair(ctx context.Context) (*cmctl.UnrevokeIssuerPairResult, error) {
	var err error
	res := &cmctl.UnrevokeIssuerPairResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	params := &cmctl.UnrevokeIssuerPairParams{
		IssuerID:   util.issuerID,
		IssuerName: util.issuerName,
	}
	res, err = cli.UnrevokeIssuerPair(ctx, params)
	if err != nil {
		return res, err
	}
	return res, err
}

func (util *Util) ListIssuerPairs(ctx context.Context) (*cmctl.ListIssuerPairsResult, error) {
	var err error
	res := &cmctl.ListIssuerPairsResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	params := &cmctl.ListIssuerPairsParams{}
	res, err = cli.ListIssuerPairs(ctx, params)
	if err != nil {
		return res, err
	}
	return res, err
}

func (util *Util) GetIssuerCertificate(ctx context.Context) (*cmctl.GetIssuerCertificateResult, error) {
	var err error
	res := &cmctl.GetIssuerCertificateResult{}
	cli, err := client.NewClient(&util.access)
	if err != nil {
		return res, err
	}
	params := &cmctl.GetIssuerCertificateParams{
		IssuerID:    util.issuerID,
		IssuerName:  util.issuerName,
		EncodingKey: util.encodingKey,
	}
	res, err = cli.GetIssuerCertificate(ctx, params)
	if err != nil {
		return res, err
	}
	certPEM, err := base64.StdEncoding.DecodeString(res.Certificate)
	if err != nil {
		return res, err
	}
	res.Certificate = string(certPEM)
	for i, cert := range res.SignerCertificates {
		caPEM, err := base64.StdEncoding.DecodeString(cert)
		if err != nil {
			return res, err
		}
		res.SignerCertificates[i] = string(caPEM)
	}
	return res, err
}