package test

import (
	"context"
	"encoding/base64"
	"fmt"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"certmanager/internal/config"
	"certmanager/internal/database"
	"certmanager/internal/logic"
	"certmanager/pkg/cm509"
	"certmanager/pkg/cmctl"
)

func TestIssuerCreateN0(t *testing.T) {
	var err error
	var lg *logic.Logic

	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)

	{
		conf := config.NewConfig()
		err = conf.ReadFile()
		require.NoError(t, err)

		db, err := database.NewDatabase(conf.DataDir)
		require.NoError(t, err)
		require.NotNil(t, db)

		err = db.InitDatabase(ctx)
		require.NoError(t, err)

		err = db.CleanDatabase(ctx)
		require.NoError(t, err)

		logicConfig := &logic.LogicConfig{
			Database: db,
		}
		lg, err = logic.NewLogic(logicConfig)
		require.NoError(t, err)
		require.NotNil(t, lg)
	}

	userID, err := lg.SeedAccount(ctx)
	require.NoError(t, err)
	require.NotZero(t, userID)

	var signerID int64
	var signerCert string
	//var signerName string
	{
		createIssuerPairParams := &cmctl.CreateIssuerPairParams{
			IssuerOrganizationName:       "Detroit cops",
			IssuerOrganizationalUnitName: "Special Operations",
			IssuerCommonName:             "Cop chief",
		}
		createIssuerPairRes, err := lg.CreateIssuerPair(ctx, userID, createIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, createIssuerPairRes)

		signerID = createIssuerPairRes.IssuerID
		//printObj("signerID", signerID)
		signerCert = createIssuerPairRes.Certificate
		//printObj("signerCert", signerCert)
		//signerName = createIssuerPairRes.IssuerName
		//printObj("signerName", signerName)

		signerCertObj, err := cm509.ParseDoubleEncodedCerificate(signerCert)
		require.NoError(t, err)
		require.NotNil(t, signerCertObj)
		//printObj("signerCertObj Subject", signerCertObj.Subject.String())
		//printObj("signerCertObj Issuer", signerCertObj.Issuer.String())

		require.Equal(t, signerCertObj.Subject.String(), signerCertObj.Issuer.String())
		require.NotZero(t, signerCertObj.Subject.String())
		require.NotZero(t, signerCertObj.Issuer.String())

		//signerPEM, err := base64.StdEncoding.DecodeString(signerCert)
		//require.NoError(t, err)
		//require.NotZero(t, len(signerPEM))
		//printObj("signerPEM", string(signerPEM))

		printObj("createIssuerPairRes", createIssuerPairRes)
	}

	var issuerID int64
	var issuerCert string
	//var issuerName string
	{
		createIssuerPairParams := &cmctl.CreateIssuerPairParams{
			IssuerCommonName:             "Intendant",
			IssuerOrganizationName:       "Detroit cops",
			IssuerOrganizationalUnitName: "Special Operations",

			SignerID: signerID,
		}
		createIssuerPairRes, err := lg.CreateIssuerPair(ctx, userID, createIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, createIssuerPairRes)

		issuerID = createIssuerPairRes.IssuerID
		//printObj("issuerID", issuerID)

		issuerCert = createIssuerPairRes.Certificate
		//printObj("issuerCert", issuerCert)

		//issuerName = createIssuerPairRes.IssuerName
		//printObj("issuerName", issuerName)

		issuerCertObj, err := cm509.ParseDoubleEncodedCerificate(issuerCert)
		require.NoError(t, err)
		require.NotNil(t, issuerCertObj)
		//printObj("issuerCertObj Subject", issuerCertObj.Subject.String())
		//printObj("issuerCertObj Issuer", issuerCertObj.Issuer.String())

		require.NotEqual(t, issuerCertObj.Subject.String(), issuerCertObj.Issuer.String())
		require.NotZero(t, issuerCertObj.Subject.String())
		require.NotZero(t, issuerCertObj.Issuer.String())

		//issuerPEM, err := base64.StdEncoding.DecodeString(issuerCert)
		//require.NoError(t, err)
		//require.NotZero(t, len(issuerPEM))
		//printObj("issuerPEM", string(issuerPEM))

		printObj("createIssuerPairRes", createIssuerPairRes)
	}
	{
		getIssuerCertificateParams := &cmctl.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, userID, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
		require.NoError(t, err)
	}

	//return

	var serviceID int64
	var serviceCert string
	//var serviceName string
	{
		createServicePairParams := &cmctl.CreateServicePairParams{
			ServiceCommonName:             "The Robocop",
			ServiceOrganizationName:       "Detroit cops",
			ServiceOrganizationalUnitName: "Special Operations",
			IssuerID:                      issuerID,
			//InetAddresses:     []string{"1.1.1.1", "1.1.1.2", "1.1.1.3"},
			Hostnames: []string{"dont.worry", "be.happy"},
		}
		createServicePairRes, err := lg.CreateServicePair(ctx, userID, createServicePairParams)
		require.NoError(t, err)
		require.NotNil(t, createServicePairRes)

		serviceID = createServicePairRes.ServiceID
		//printObj("serviceID", serviceID)

		serviceCert = createServicePairRes.Certificate
		//printObj("serviceCert", serviceCert)

		//serviceName = createServicePairRes.ServiceName
		//printObj("serviceName", serviceName)

		serviceCertObj, err := cm509.ParseDoubleEncodedCerificate(serviceCert)
		require.NoError(t, err)
		require.NotNil(t, serviceCertObj)
		//printObj("serviceCertObj Subject", serviceCertObj.Subject.String())
		//printObj("serviceCertObj Issuer", serviceCertObj.Issuer.String())
		//printObj("serviceCertObj DNSNames", serviceCertObj.DNSNames)
		//printObj("serviceCertObj IP addresses", serviceCertObj.IPAddresses)

		require.NotEqual(t, serviceCertObj.Subject.String(), serviceCertObj.Issuer.String())
		require.NotZero(t, len(serviceCertObj.Subject.String()))
		require.NotZero(t, len(serviceCertObj.Issuer.String()))

		servicePEM, err := base64.StdEncoding.DecodeString(serviceCert)
		require.NoError(t, err)
		require.NotZero(t, len(servicePEM))
		//printObj("servicePEM", string(servicePEM))

		printObj("createServicePairRes", createServicePairRes)

	}

	return

	{
		listIssuerPairsParams := &cmctl.ListIssuerPairsParams{}
		listIssuerPairsRes, err := lg.ListIssuerPairs(ctx, userID, listIssuerPairsParams)
		require.NoError(t, err)
		require.NotNil(t, listIssuerPairsRes)
		require.NotZero(t, len(listIssuerPairsRes.Issuers))

		printObj("listIssuerPairRes", listIssuerPairsRes)
	}
	{
		getServicePairParams := &cmctl.GetServicePairParams{
			ServiceID: serviceID,
		}
		getServicePairRes, err := lg.GetServicePair(ctx, userID, getServicePairParams)
		require.NoError(t, err)
		require.NotNil(t, getServicePairRes)
		require.NotZero(t, len(getServicePairRes.Certificate))
		require.False(t, getServicePairRes.Revoked)

		printObj("getServicePairRes.IssuerCertificates", getServicePairRes.IssuerCertificates)
	}

}

func XXXTestIssuerCreateN2(t *testing.T) {
	var err error
	var lg *logic.Logic

	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)

	{
		conf := config.NewConfig()
		err = conf.ReadFile()
		require.NoError(t, err)

		db, err := database.NewDatabase(conf.DataDir)
		require.NoError(t, err)
		require.NotNil(t, db)

		err = db.InitDatabase(ctx)
		require.NoError(t, err)

		logicConfig := &logic.LogicConfig{
			Database: db,
		}
		lg, err = logic.NewLogic(logicConfig)
		require.NoError(t, err)
		require.NotNil(t, lg)
	}

	userID, err := lg.SeedAccount(ctx)
	require.NoError(t, err)
	require.NotZero(t, userID)

	issuerCommonName := "foo.bar"
	var issuerID int64
	var issuerCert string
	{
		createIssuerPairParams := &cmctl.CreateIssuerPairParams{
			IssuerCommonName: issuerCommonName,
		}
		createIssuerPairRes, err := lg.CreateIssuerPair(ctx, userID, createIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, createIssuerPairRes)
		issuerID = createIssuerPairRes.IssuerID
		printObj("issuerID", issuerID)
		printObj("issuerID", issuerID)
	}
	{
		getIssuerCertificateParams := &cmctl.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, userID, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
		require.NoError(t, err)

		issuerCert = getIssuerCertificateRes.Certificate
		require.NotZero(t, len(issuerCert))
		printObj("issuerCert", string(issuerCert))
	}
	{
		revokeIssuerPairParams := &cmctl.RevokeIssuerPairParams{
			IssuerID: issuerID,
		}
		revokeIssuerPairRes, err := lg.RevokeIssuerPair(ctx, userID, revokeIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, revokeIssuerPairRes)

		printObj("revokeIssuerPairRes", revokeIssuerPairRes)
		require.NoError(t, err)
	}
	{
		getIssuerCertificateParams := &cmctl.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, userID, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))
		require.True(t, getIssuerCertificateRes.Revoked)

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
	}
	{
		unrevokeIssuerPairParams := &cmctl.UnrevokeIssuerPairParams{
			IssuerID: issuerID,
		}
		unrevokeIssuerPairRes, err := lg.UnrevokeIssuerPair(ctx, userID, unrevokeIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, unrevokeIssuerPairRes)

		printObj("unrevokeIssuerPairRes", unrevokeIssuerPairRes)
		require.NoError(t, err)
	}
	{
		getIssuerCertificateParams := &cmctl.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, userID, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))
		require.False(t, getIssuerCertificateRes.Revoked)

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
	}
	{
		listIssuerPairsParams := &cmctl.ListIssuerPairsParams{}
		listIssuerPairsRes, err := lg.ListIssuerPairs(ctx, userID, listIssuerPairsParams)
		require.NoError(t, err)
		require.NotNil(t, listIssuerPairsRes)
		require.NotZero(t, len(listIssuerPairsRes.Issuers))

		printObj("listIssuerPairRes", listIssuerPairsRes)
	}
	{
		for i := 0; i < 3; i++ {
			createIssuerPairParams := &cmctl.CreateIssuerPairParams{
				IssuerCommonName: fmt.Sprintf("sub%0d.%s", i, issuerCommonName),
			}
			createIssuerPairRes, err := lg.CreateIssuerPair(ctx, userID, createIssuerPairParams)
			require.NoError(t, err)
			require.NotNil(t, createIssuerPairRes)
			issuerID = createIssuerPairRes.IssuerID
			printObj("issuerID", issuerID)
		}
	}
	{
		listIssuerPairsParams := &cmctl.ListIssuerPairsParams{}
		listIssuerPairsRes, err := lg.ListIssuerPairs(ctx, userID, listIssuerPairsParams)
		require.NoError(t, err)
		require.NotNil(t, listIssuerPairsRes)
		require.NotZero(t, len(listIssuerPairsRes.Issuers))

		printObj("listIssuerPairRes", listIssuerPairsRes)
	}
	serviceCommonName := "make.love.not.war"
	var serviceID int64
	{
		createServicePairParams := &cmctl.CreateServicePairParams{
			ServiceCommonName: serviceCommonName,
			IssuerID:          issuerID,
		}
		createServicePairRes, err := lg.CreateServicePair(ctx, userID, createServicePairParams)
		printObj("createServicePairRes", createServicePairRes)

		require.NoError(t, err)
		require.NotNil(t, createServicePairRes)
		serviceID = createServicePairRes.ServiceID
		printObj("serviceID", serviceID)
	}
	{
		getServicePairParams := &cmctl.GetServicePairParams{
			ServiceID: serviceID,
		}
		getServicePairRes, err := lg.GetServicePair(ctx, userID, getServicePairParams)
		require.NoError(t, err)
		require.NotNil(t, getServicePairRes)
		require.NotZero(t, len(getServicePairRes.Certificate))
		require.False(t, getServicePairRes.Revoked)

		printObj("getServicePairRes", getServicePairRes)
	}
}