// This file is part of MinIO Console Server
// Copyright (c) 2021 MinIO, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package operatorapi

import (
	"context"
	"fmt"
	"sort"

	errors "github.com/minio/console/restapi"

	miniov1 "github.com/minio/operator/pkg/apis/minio.min.io/v1"

	"github.com/go-openapi/runtime/middleware"
	"github.com/minio/console/cluster"
	"github.com/minio/console/models"
	"github.com/minio/console/operatorapi/operations"
	"github.com/minio/console/operatorapi/operations/operator_api"
	v1 "k8s.io/api/certificates/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func registerVolumesHandlers(api *operations.OperatorAPI) {
	api.OperatorAPIListPVCsHandler = operator_api.ListPVCsHandlerFunc(func(params operator_api.ListPVCsParams, session *models.Principal) middleware.Responder {
		payload, err := getPVCsResponse(session, params)
		if err != nil {
			return operator_api.NewListPVCsDefault(int(err.Code)).WithPayload(err)
		}

		return operator_api.NewListPVCsOK().WithPayload(payload)
	})

	api.OperatorAPIListPVCsForTenantHandler = operator_api.ListPVCsForTenantHandlerFunc(func(params operator_api.ListPVCsForTenantParams, session *models.Principal) middleware.Responder {
		payload, err := getPVCsForTenantResponse(session, params)
		if err != nil {
			return operator_api.NewListPVCsForTenantDefault(int(err.Code)).WithPayload(err)
		}

		return operator_api.NewListPVCsForTenantOK().WithPayload(payload)
	})

	api.OperatorAPIListTenantCertificateSigningRequestHandler = operator_api.ListTenantCertificateSigningRequestHandlerFunc(func(params operator_api.ListTenantCertificateSigningRequestParams, session *models.Principal) middleware.Responder {
		payload, err := getTenantCSResponse(session, params)
		if err != nil {
			return operator_api.NewListTenantCertificateSigningRequestDefault(int(err.Code)).WithPayload(err)
		}

		return operator_api.NewListTenantCertificateSigningRequestOK().WithPayload(payload)
	})

	api.OperatorAPIDeletePVCHandler = operator_api.DeletePVCHandlerFunc(func(params operator_api.DeletePVCParams, session *models.Principal) middleware.Responder {
		err := getDeletePVCResponse(session, params)
		if err != nil {
			return operator_api.NewDeletePVCDefault(int(err.Code)).WithPayload(err)
		}
		return nil
	})

	api.OperatorAPIGetPVCEventsHandler = operator_api.GetPVCEventsHandlerFunc(func(params operator_api.GetPVCEventsParams, session *models.Principal) middleware.Responder {
		payload, err := getPVCEventsResponse(session, params)
		if err != nil {
			return operator_api.NewGetPVCEventsDefault(int(err.Code)).WithPayload(err)
		}

		return operator_api.NewGetPVCEventsOK().WithPayload(payload)
	})

	api.OperatorAPIGetPVCDescribeHandler = operator_api.GetPVCDescribeHandlerFunc(func(params operator_api.GetPVCDescribeParams, session *models.Principal) middleware.Responder {
		payload, err := getPVCDescribeResponse(session, params)
		if err != nil {
			return operator_api.NewGetPVCDescribeDefault(int(err.Code)).WithPayload(err)
		}
		return operator_api.NewGetPVCDescribeOK().WithPayload(payload)
	})
}

func getPVCsResponse(session *models.Principal, params operator_api.ListPVCsParams) (*models.ListPVCsResponse, *models.Error) {
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	clientset, err := cluster.K8sClient(session.STSSessionToken)
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}

	// Filter Tenant PVCs. They keep their v1 tenant annotation
	listOpts := metav1.ListOptions{
		LabelSelector: miniov1.TenantLabel,
	}

	// List all PVCs
	listAllPvcs, err2 := clientset.CoreV1().PersistentVolumeClaims("").List(ctx, listOpts)

	if err2 != nil {
		return nil, errors.ErrorWithContext(ctx, err2)
	}

	var ListPVCs []*models.PvcsListResponse

	for _, pvc := range listAllPvcs.Items {
		status := string(pvc.Status.Phase)
		if pvc.DeletionTimestamp != nil {
			status = "Terminating"
		}
		pvcResponse := models.PvcsListResponse{
			Name:         pvc.Name,
			Age:          pvc.CreationTimestamp.String(),
			Capacity:     pvc.Status.Capacity.Storage().String(),
			Namespace:    pvc.Namespace,
			Status:       status,
			StorageClass: *pvc.Spec.StorageClassName,
			Volume:       pvc.Spec.VolumeName,
			Tenant:       pvc.Labels["v1.min.io/tenant"],
		}
		ListPVCs = append(ListPVCs, &pvcResponse)
	}

	PVCsResponse := models.ListPVCsResponse{
		Pvcs: ListPVCs,
	}

	return &PVCsResponse, nil
}

func getPVCsForTenantResponse(session *models.Principal, params operator_api.ListPVCsForTenantParams) (*models.ListPVCsResponse, *models.Error) {
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	clientset, err := cluster.K8sClient(session.STSSessionToken)
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}

	// Filter Tenant PVCs. They keep their v1 tenant annotation
	listOpts := metav1.ListOptions{
		LabelSelector: fmt.Sprintf("v1.min.io/tenant=%s", params.Tenant),
	}

	// List all PVCs
	listAllPvcs, err2 := clientset.CoreV1().PersistentVolumeClaims(params.Namespace).List(ctx, listOpts)

	if err2 != nil {
		return nil, errors.ErrorWithContext(ctx, err2)
	}

	var ListPVCs []*models.PvcsListResponse

	for _, pvc := range listAllPvcs.Items {
		status := string(pvc.Status.Phase)
		if pvc.DeletionTimestamp != nil {
			status = "Terminating"
		}
		pvcResponse := models.PvcsListResponse{
			Name:         pvc.Name,
			Age:          pvc.CreationTimestamp.String(),
			Capacity:     pvc.Status.Capacity.Storage().String(),
			Namespace:    pvc.Namespace,
			Status:       status,
			StorageClass: *pvc.Spec.StorageClassName,
			Volume:       pvc.Spec.VolumeName,
			Tenant:       pvc.Labels["v1.min.io/tenant"],
		}
		ListPVCs = append(ListPVCs, &pvcResponse)
	}

	PVCsResponse := models.ListPVCsResponse{
		Pvcs: ListPVCs,
	}

	return &PVCsResponse, nil
}

func getDeletePVCResponse(session *models.Principal, params operator_api.DeletePVCParams) *models.Error {
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	// get Kubernetes Client
	clientset, err := cluster.K8sClient(session.STSSessionToken)
	if err != nil {
		return errors.ErrorWithContext(ctx, err)
	}
	listOpts := metav1.ListOptions{
		LabelSelector: fmt.Sprintf("v1.min.io/tenant=%s", params.Tenant),
		FieldSelector: fmt.Sprintf("metadata.name=%s", params.PVCName),
	}
	if err = clientset.CoreV1().PersistentVolumeClaims(params.Namespace).DeleteCollection(ctx, metav1.DeleteOptions{}, listOpts); err != nil {
		return errors.ErrorWithContext(ctx, err)
	}
	return nil
}

func getPVCEventsResponse(session *models.Principal, params operator_api.GetPVCEventsParams) (models.EventListWrapper, *models.Error) {
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	clientset, err := cluster.K8sClient(session.STSSessionToken)
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}
	PVC, err := clientset.CoreV1().PersistentVolumeClaims(params.Namespace).Get(ctx, params.PVCName, metav1.GetOptions{})
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}
	events, err := clientset.CoreV1().Events(params.Namespace).List(ctx, metav1.ListOptions{FieldSelector: fmt.Sprintf("involvedObject.uid=%s", PVC.UID)})
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}
	retval := models.EventListWrapper{}
	for i := 0; i < len(events.Items); i++ {
		retval = append(retval, &models.EventListElement{
			Namespace: events.Items[i].Namespace,
			LastSeen:  events.Items[i].LastTimestamp.Unix(),
			Message:   events.Items[i].Message,
			EventType: events.Items[i].Type,
			Reason:    events.Items[i].Reason,
		})
	}
	sort.SliceStable(retval, func(i int, j int) bool {
		return retval[i].LastSeen < retval[j].LastSeen
	})
	return retval, nil
}

func getTenantCSResponse(session *models.Principal, params operator_api.ListTenantCertificateSigningRequestParams) (*models.CsrElements, *models.Error) {
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	clientset, err := cluster.K8sClient(session.STSSessionToken)
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}

	// Get CSRs by Label "v1.min.io/tenant=" + params.Tenant
	listByTenantLabel := metav1.ListOptions{LabelSelector: "v1.min.io/tenant=" + params.Tenant}
	listResult, listError := clientset.CertificatesV1().CertificateSigningRequests().List(ctx, listByTenantLabel)
	if listError != nil {
		return nil, errors.ErrorWithContext(ctx, listError)
	}

	// Get CSR by label "v1.min.io/kes=" + params.Tenant + "-kes"
	listByKESLabel := metav1.ListOptions{LabelSelector: "v1.min.io/kes=" + params.Tenant + "-kes"}
	listKESResult, listKESError := clientset.CertificatesV1().CertificateSigningRequests().List(ctx, listByKESLabel)
	if listKESError != nil {
		return nil, errors.ErrorWithContext(ctx, listKESError)
	}

	var listOfCSRs []v1.CertificateSigningRequest
	for index := 0; index < len(listResult.Items); index++ {
		listOfCSRs = append(listOfCSRs, listResult.Items[index])
	}
	for index := 0; index < len(listKESResult.Items); index++ {
		listOfCSRs = append(listOfCSRs, listKESResult.Items[index])
	}

	var arrayElements []*models.CsrElement
	for index := 0; index < len(listOfCSRs); index++ {
		csrResult := listOfCSRs[index]
		annotations := []*models.Annotation{}
		for k, v := range csrResult.ObjectMeta.Annotations {
			annotations = append(annotations, &models.Annotation{Key: k, Value: v})
		}
		var DeletionGracePeriodSeconds int64
		DeletionGracePeriodSeconds = 0
		if csrResult.ObjectMeta.DeletionGracePeriodSeconds != nil {
			DeletionGracePeriodSeconds = *csrResult.ObjectMeta.DeletionGracePeriodSeconds
		}
		messages := ""
		// A CSR.Status can contain multiple Conditions
		for i := 0; i < len(csrResult.Status.Conditions); i++ {
			messages = messages + " " + csrResult.Status.Conditions[i].Message
		}
		retval := &models.CsrElement{
			Name:                       csrResult.ObjectMeta.Name,
			Annotations:                annotations,
			DeletionGracePeriodSeconds: DeletionGracePeriodSeconds,
			GenerateName:               csrResult.ObjectMeta.GenerateName,
			Generation:                 csrResult.ObjectMeta.Generation,
			Namespace:                  csrResult.ObjectMeta.Namespace,
			ResourceVersion:            csrResult.ObjectMeta.ResourceVersion,
			Status:                     messages,
		}
		arrayElements = append(arrayElements, retval)
	}
	result := &models.CsrElements{CsrElement: arrayElements}
	return result, nil
}

func getPVCDescribeResponse(session *models.Principal, params operator_api.GetPVCDescribeParams) (*models.DescribePVCWrapper, *models.Error) {
	clientSet, err := cluster.K8sClient(session.STSSessionToken)
	ctx, cancel := context.WithCancel(params.HTTPRequest.Context())
	defer cancel()
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}
	k8sClient := k8sClient{client: clientSet}
	return getPVCDescribe(ctx, params.Namespace, params.PVCName, &k8sClient)
}

func getPVCDescribe(ctx context.Context, namespace string, pvcName string, clientSet K8sClientI) (*models.DescribePVCWrapper, *models.Error) {
	pvc, err := clientSet.getPVC(ctx, namespace, pvcName, metav1.GetOptions{})
	if err != nil {
		return nil, errors.ErrorWithContext(ctx, err)
	}
	accessModes := []string{}
	for _, a := range pvc.Status.AccessModes {
		accessModes = append(accessModes, string(a))
	}
	return &models.DescribePVCWrapper{
		Name:         pvc.Name,
		Namespace:    pvc.Namespace,
		StorageClass: *pvc.Spec.StorageClassName,
		Status:       string(pvc.Status.Phase),
		Volume:       pvc.Spec.VolumeName,
		Labels:       castLabels(pvc.Labels),
		Annotations:  castAnnotations(pvc.Annotations),
		Finalizers:   pvc.Finalizers,
		Capacity:     pvc.Status.Capacity.Storage().String(),
		AccessModes:  accessModes,
		VolumeMode:   string(*pvc.Spec.VolumeMode),
	}, nil
}

func castLabels(labelsToCast map[string]string) (labels []*models.Label) {
	for k, v := range labelsToCast {
		labels = append(labels, &models.Label{Key: k, Value: v})
	}
	return labels
}

func castAnnotations(annotationsToCast map[string]string) (annotations []*models.Annotation) {
	for k, v := range annotationsToCast {
		annotations = append(annotations, &models.Annotation{Key: k, Value: v})
	}
	return annotations
}