package logic

import (
	"context"
	"fmt"

	cmapi "certmanager/api/certmanagercontrol"
	"certmanager/internal/descriptor"
	"certmanager/pkg/cm509"
)

func (lg *Logic) CreateServicePair(ctx context.Context, params *cmapi.CreateServicePairParams) (*cmapi.CreateServicePairResult, error) {
	var err error
	res := &cmapi.CreateServicePairResult{}

	var issuerDescr *descriptor.Issuer
	var issuerExists bool
	switch {
	case params.IssuerID != 0:
		issuerExists, issuerDescr, err = lg.db.GetIssuerByID(ctx, params.IssuerID)
		if !issuerExists {
			err := fmt.Errorf("No signer with id was found", params.IssuerID)
			if err != nil {
				return res, err
			}
		}
	case params.IssuerName != "":
		issuerExists, issuerDescr, err = lg.db.GetIssuerByName(ctx, params.IssuerName)
		if !issuerExists {
			err := fmt.Errorf("No signer with name %s was found", params.IssuerName)
			if err != nil {
				return res, err
			}
		}
	default:
		err := fmt.Errorf("Issuer ID or name is not specified")
		if err != nil {
			return res, err
		}
	}
	if issuerDescr == nil {
		err := fmt.Errorf("Issuer descriptor is nil")
		if err != nil {
			return res, err
		}
	}
	if issuerDescr.Revoked {
		err := fmt.Errorf("The issuer revoked")
		if err != nil {
			return res, err
		}
	}

	createServicePairParams := &cm509.CreateServicePairParams{
		CommonName:  params.ServiceCommonName,
		IssuerKey:   issuerDescr.Key,
		IssuerCert:  issuerDescr.Cert,
		IPAddresses: params.InetAddresses,
		DNSNames:    params.Hostnames,
	}
	createSericePairRes, err := cm509.CreateServicePair(createServicePairParams)
	if err != nil {
		return res, err
	}

	serviceDescr := &descriptor.Service{
		Name:       createSericePairRes.Name,
		IssuerID:   issuerDescr.ID,
		IssuerName: issuerDescr.Name,
		Cert:       createSericePairRes.Cert,
		Key:        createSericePairRes.Key,
	}
	serviceID, err := lg.db.InsertService(ctx, serviceDescr)
	if err != nil {
		return res, err
	}
	res.ServiceName = createSericePairRes.Name
	res.ServiceID = serviceID
	res.Certificate = createSericePairRes.Cert
	res.Key = createSericePairRes.Key
	res.IssuerID = issuerDescr.ID
	res.IssuerCertificate = issuerDescr.Cert
	return res, err
}

func (lg *Logic) GetServicePair(ctx context.Context, params *cmapi.GetServicePairParams) (*cmapi.GetServicePairResult, error) {
	var err error
	res := &cmapi.GetServicePairResult{}
	var serviceDescr *descriptor.Service
	var serviceExists bool
	switch {
	case params.ServiceID != 0:
		serviceExists, serviceDescr, err = lg.db.GetServiceByID(ctx, params.ServiceID)
		if !serviceExists {
			err := fmt.Errorf("No signer with this ID was found")
			if err != nil {
				return res, err
			}
		}
	case params.ServiceName != "":
		serviceExists, serviceDescr, err = lg.db.GetServiceByName(ctx, params.ServiceName)
		if !serviceExists {
			err := fmt.Errorf("No signer with this common name was found")
			if err != nil {
				return res, err
			}
		}
	default:
		err := fmt.Errorf("Service ID or name is not specified")
		if err != nil {
			return res, err
		}
	}
	if serviceDescr == nil {
		err := fmt.Errorf("Service descriptor is nil")
		if err != nil {
			return res, err
		}
	}
	res.Certificate = serviceDescr.Cert
	res.Key = serviceDescr.Key
	res.IssuerID = serviceDescr.IssuerID
	res.IssuerName = serviceDescr.IssuerName
	res.Revoked = serviceDescr.Revoked
	return res, err
}

func (lg *Logic) ListServicePairs(ctx context.Context, params *cmapi.ListServicePairsParams) (*cmapi.ListServicePairsResult, error) {
	var err error
	res := &cmapi.ListServicePairsResult{
		Services: make([]*cmapi.ServiceShortDescriptor, 0),
	}

	listServices, err := lg.db.ListServices(ctx)
	if err != nil {
		return res, err
	}
	for _, service := range listServices {
		serviceShortDescr := cmapi.ServiceShortDescriptor{
			ServiceID:  service.ID,
			IssuerID:   service.IssuerID,
			IssuerName: service.IssuerName,
			Name:       service.Name,
			Revoked:    service.Revoked,
		}
		res.Services = append(res.Services, &serviceShortDescr)
	}
	return res, err
}

func (lg *Logic) RevokeServicePair(ctx context.Context, params *cmapi.RevokeServicePairParams) (*cmapi.RevokeServicePairResult, error) {
	var err error
	res := &cmapi.RevokeServicePairResult{}

	var serviceDescr *descriptor.Service
	var serviceExists bool
	switch {
	case params.ServiceID != 0:
		serviceExists, serviceDescr, err = lg.db.GetServiceByID(ctx, params.ServiceID)
		if !serviceExists {
			err := fmt.Errorf("No signer with id %d was found", params.ServiceID)
			if err != nil {
				return res, err
			}
		}
	case params.ServiceName != "":
		serviceExists, serviceDescr, err = lg.db.GetServiceByName(ctx, params.ServiceName)
		if !serviceExists {
			err := fmt.Errorf("No signer with name %s was found", params.ServiceName)
			if err != nil {
				return res, err
			}
		}
	default:
		err := fmt.Errorf("Service ID or name is not specified")
		if err != nil {
			return res, err
		}
	}
	if serviceDescr == nil {
		err := fmt.Errorf("Service descriptor is nil")
		if err != nil {
			return res, err
		}
	}
	if !serviceDescr.Revoked {
		serviceDescr.Revoked = true
		err = lg.db.UpdateServiceByID(ctx, serviceDescr.ID, serviceDescr)
		if err != nil {
			return res, err
		}
	}
	return res, err
}

func (lg *Logic) UnrevokeServicePair(ctx context.Context, params *cmapi.UnrevokeServicePairParams) (*cmapi.UnrevokeServicePairResult, error) {
	var err error
	res := &cmapi.UnrevokeServicePairResult{}

	var serviceDescr *descriptor.Service
	var serviceExists bool
	switch {
	case params.ServiceID != 0:
		serviceExists, serviceDescr, err = lg.db.GetServiceByID(ctx, params.ServiceID)
		if !serviceExists {
			err := fmt.Errorf("No signer with id %d was found", params.ServiceID)
			if err != nil {
				return res, err
			}
		}
	case params.ServiceName != "":
		serviceExists, serviceDescr, err = lg.db.GetServiceByName(ctx, params.ServiceName)
		if !serviceExists {
			err := fmt.Errorf("No signer with name %s was found", params.ServiceName)
			if err != nil {
				return res, err
			}
		}
	default:
		err := fmt.Errorf("Service ID or name is not specified")
		if err != nil {
			return res, err
		}
	}
	if serviceDescr == nil {
		err := fmt.Errorf("Service descriptor is nil")
		if err != nil {
			return res, err
		}
	}
	if serviceDescr.Revoked {
		serviceDescr.Revoked = false
		err = lg.db.UpdateServiceByID(ctx, serviceDescr.ID, serviceDescr)
		if err != nil {
			return res, err
		}
	}
	return res, err
}