/*
Copyright (c) 2026 Huawei Technologies Co., Ltd.
openFuyao is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/

package driver

import (
	"context"
	"testing"

	csi "github.com/container-storage-interface/spec/lib/go/csi"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/codes"

	"gitcode.com/openFuyao/ub-ssu-csi/pkg/backend"
	"gitcode.com/openFuyao/ub-ssu-csi/pkg/kube"
)

const (
	testSize1GiB  = 1 << 30  // 1 GiB
	testSize2GiB  = 2 << 30  // 2 GiB
	testSize4GiB  = 4 << 30  // 4 GiB
	testSize5GiB  = 5 << 30  // 5 GiB
	testSize10GiB = 10 << 30 // 10 GiB
)

// controllerStorageManager 包装 node_test.go 中的 fakeStorageManager，
// 添加 controller 测试需要的字段。
type controllerStorageManager struct {
	*fakeStorageManager // 继承 node_test.go 中的 fakeStorageManager
	allocVolumeResult   *backend.VolumeInfo
	allocVolumeError    error
	deleteVolumeError   error
	allocVolumeCalled   bool
	deleteVolumeCalled  bool
	allocatedVolumeID   string
}

func (c *controllerStorageManager) AllocVolume(
	name string,
	sizeBytes uint64,
	config backend.LogicalConfig,
) (*backend.VolumeInfo, error) {
	c.allocVolumeCalled = true
	c.allocatedVolumeID = name
	return c.allocVolumeResult, c.allocVolumeError
}

func (c *controllerStorageManager) DeleteVolume(volumeID string) error {
	c.deleteVolumeCalled = true
	if c.deleteVolumeError != nil {
		return c.deleteVolumeError
	}
	return c.fakeStorageManager.DeleteVolume(volumeID)
}

// fakePVCReader 实现 kube.PVCReader 接口，用于 controller 测试。
type fakePVCReader struct {
	annotations map[string]string
	err         error
}

func (f *fakePVCReader) GetPVCAnnotations(ctx context.Context, namespace, name string) (map[string]string, error) {
	return f.annotations, f.err
}

// 类型断言确保 fakePVCReader 实现了 kube.PVCReader 接口
var _ kube.PVCReader = (*fakePVCReader)(nil)

func makeCreateVolumeRequest(
	name string, sizeBytes int64, params map[string]string, pvcName, pvcNamespace string,
) *csi.CreateVolumeRequest {
	reqParams := make(map[string]string)
	if params != nil {
		for k, v := range params {
			reqParams[k] = v
		}
	}
	if pvcName != "" {
		reqParams[pvcNameKey] = pvcName
	}
	if pvcNamespace != "" {
		reqParams[pvcNamespaceKey] = pvcNamespace
	}

	return &csi.CreateVolumeRequest{
		Name: name,
		CapacityRange: &csi.CapacityRange{
			RequiredBytes: sizeBytes,
		},
		Parameters: reqParams,
		VolumeCapabilities: []*csi.VolumeCapability{
			{
				AccessMode: &csi.VolumeCapability_AccessMode{
					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
				},
				AccessType: &csi.VolumeCapability_Block{
					Block: &csi.VolumeCapability_BlockVolume{},
				},
			},
		},
	}
}

func makeDeleteVolumeRequest(volumeID string) *csi.DeleteVolumeRequest {
	return &csi.DeleteVolumeRequest{
		VolumeId: volumeID,
	}
}

func makeVolumeInfo(volumeID string, sizeBytes uint64, namespaces []backend.Namespace) *backend.VolumeInfo {
	return &backend.VolumeInfo{
		VolumeID:   volumeID,
		SizeBytes:  sizeBytes,
		Namespaces: namespaces,
		Strategy:   0,
	}
}

func makeNamespace(deviceUUID, devicePath, peerEid, subnqn string) backend.Namespace {
	return backend.Namespace{
		DeviceUUID: deviceUUID,
		DevicePath: devicePath,
		PeerEid:    peerEid,
		Subnqn:     subnqn,
	}
}

func TestCreateVolumeSingleNamespaceSuccess(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult: makeVolumeInfo("vol-1", testSize2GiB, []backend.Namespace{
			makeNamespace("uuid-123", "/dev/nvme0n1", "eid-1", "nqn-1"),
		}),
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize2GiB, nil, "", "")
	resp, err := cs.CreateVolume(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "vol-1", resp.Volume.VolumeId)
	assert.Equal(t, int64(testSize2GiB), resp.Volume.CapacityBytes)
	assert.NotEmpty(t, resp.Volume.VolumeContext)
	assert.Contains(t, resp.Volume.VolumeContext, ctxKeyVolumeID)
	assert.Contains(t, resp.Volume.VolumeContext, ctxKeyDeviceID)
	assert.True(t, fakeStorage.allocVolumeCalled)
}

func TestCreateVolumeMultipleNamespaceSuccess(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult: makeVolumeInfo("vol-2", testSize4GiB, []backend.Namespace{
			makeNamespace("uuid-1", "/dev/nvme0n1", "eid-1", "nqn-1"),
			makeNamespace("uuid-2", "/dev/nvme1n1", "eid-2", "nqn-2"),
		}),
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	reqParams := map[string]string{
		scKeyAllocStrategy: "0",
	}
	pvcAnnotations := map[string]string{
		pvcKeyNsnum: "2",
	}
	req := makeCreateVolumeRequest("vol-2", testSize4GiB, reqParams, "pvc-1", "default")
	fakePVCReader.annotations = pvcAnnotations

	resp, err := cs.CreateVolume(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "vol-2", resp.Volume.VolumeId)
	assert.Equal(t, int64(testSize4GiB), resp.Volume.CapacityBytes)
	assert.True(t, fakeStorage.allocVolumeCalled)
}

func TestCreateVolumeWithPVCAnnotations(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult: makeVolumeInfo("vol-3", testSize2GiB, []backend.Namespace{
			makeNamespace("uuid-456", "/dev/nvme0n2", "eid-3", "nqn-3"),
		}),
	}
	fakePVCReader := &fakePVCReader{
		annotations: map[string]string{
			pvcKeyLbaFormat: "1",
			pvcKeyNsnum:     "1",
		},
	}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-3", testSize2GiB, nil, "my-pvc", "my-namespace")
	resp, err := cs.CreateVolume(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.True(t, fakeStorage.allocVolumeCalled)
	assert.Equal(t, "vol-3", fakeStorage.allocatedVolumeID)
}

func TestCreateVolumeWithStorageClassParams(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult: makeVolumeInfo("vol-4", testSize10GiB, []backend.Namespace{
			makeNamespace("uuid-789", "/dev/nvme0n3", "eid-4", "nqn-4"),
		}),
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	reqParams := map[string]string{
		scKeyRaidLevel:     "5",
		scKeyAllocStrategy: "2",
	}
	req := makeCreateVolumeRequest("vol-4", testSize10GiB, reqParams, "", "")
	resp, err := cs.CreateVolume(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.True(t, fakeStorage.allocVolumeCalled)
}

func TestCreateVolumeVolumeIdMatchesRequestName(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult: makeVolumeInfo("test-volume-name", testSize1GiB, []backend.Namespace{
			makeNamespace("uuid-001", "/dev/nvme0n4", "eid-5", "nqn-5"),
		}),
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("test-volume-name", testSize1GiB, nil, "", "")
	resp, err := cs.CreateVolume(context.Background(), req)
	require.NoError(t, err)
	assert.Equal(t, "test-volume-name", resp.Volume.VolumeId)
}

func TestCreateVolumeVolumeNameMissing(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.CreateVolumeRequest{
		CapacityRange: &csi.CapacityRange{RequiredBytes: testSize1GiB},
		VolumeCapabilities: []*csi.VolumeCapability{
			{
				AccessMode: &csi.VolumeCapability_AccessMode{
					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
				},
			},
		},
	}

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "volume name missing")
}

func TestCreateVolumeVolumeNameTooLong(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	longName := "very-long-volume-name-that-exceeds-the-maximum-length-limit-of-48-characters"
	req := makeCreateVolumeRequest(longName, testSize1GiB, nil, "", "")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "exceeds UBSE limit")
}

func TestCreateVolumeVolumeCapabilitiesMissing(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.CreateVolumeRequest{
		Name:          "vol-1",
		CapacityRange: &csi.CapacityRange{RequiredBytes: testSize1GiB},
	}

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "volume capabilities missing")
}

func TestCreateVolumeInvalidVolumeCapability(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.CreateVolumeRequest{
		Name:          "vol-1",
		CapacityRange: &csi.CapacityRange{RequiredBytes: testSize1GiB},
		VolumeCapabilities: []*csi.VolumeCapability{
			{
				AccessMode: &csi.VolumeCapability_AccessMode{
					Mode: csi.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER,
				},
			},
		},
	}

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "only ReadWriteOnce")
}

func TestCreateVolumeInvalidSize(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", 512<<20, nil, "", "") // 512MiB < 1GiB

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "smaller than minimum")
}

func TestCreateVolumeReadPVCAnnotationsError(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{
		err: context.DeadlineExceeded,
	}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize1GiB, nil, "pvc-1", "default")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.Aborted, getErrorCode(err))
	assert.Contains(t, err.Error(), "read pvc annotations")
}

func TestCreateVolumeInvalidStorageClassParams(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{
		annotations: map[string]string{
			pvcKeyNsnum: "invalid",
		},
	}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize1GiB, nil, "pvc-1", "default")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "invalid nsnum")
}

func TestCreateVolumeAllocVolumeError(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeError:   context.DeadlineExceeded,
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize1GiB, nil, "", "")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.Internal, getErrorCode(err))
	assert.Contains(t, err.Error(), "AllocVolume failed")
}

func TestCreateVolumeAllocVolumeReturnsNil(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		allocVolumeResult:  nil,
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize1GiB, nil, "", "")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.Internal, getErrorCode(err))
	assert.Contains(t, err.Error(), "AllocVolume returned nil volume")
}

func TestCreateVolumeMissingAllocStrategyWhenNsnumGreaterThanOne(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{
		annotations: map[string]string{
			pvcKeyNsnum: "2",
		},
	}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeCreateVolumeRequest("vol-1", testSize1GiB, nil, "pvc-1", "default")

	_, err := cs.CreateVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "allocStrategy is required")
}

func TestDeleteVolumeSuccess(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeDeleteVolumeRequest("vol-1")
	resp, err := cs.DeleteVolume(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.True(t, fakeStorage.deleteVolumeCalled)
}

func TestDeleteVolumeIdempotent(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	// 重复删除同一个volume应该成功（UBSE保证幂等性）
	req := makeDeleteVolumeRequest("vol-1")
	resp1, err1 := cs.DeleteVolume(context.Background(), req)
	require.NoError(t, err1)
	require.NotNil(t, resp1)

	resp2, err2 := cs.DeleteVolume(context.Background(), req)
	require.NoError(t, err2)
	require.NotNil(t, resp2)
}

func TestDeleteVolumeVolumeIdMissing(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeDeleteVolumeRequest("")
	_, err := cs.DeleteVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
	assert.Contains(t, err.Error(), "volume ID missing")
}

func TestDeleteVolumeDeleteVolumeError(t *testing.T) {
	fakeStorage := &controllerStorageManager{
		fakeStorageManager: newFakeStorageManager(),
		deleteVolumeError:  context.DeadlineExceeded,
	}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := makeDeleteVolumeRequest("vol-1")
	_, err := cs.DeleteVolume(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.Internal, getErrorCode(err))
	assert.Contains(t, err.Error(), "DeleteVolume failed")
}

func TestValidateVolumeCapabilitiesSuccess(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.ValidateVolumeCapabilitiesRequest{
		VolumeId: "vol-1",
		VolumeCapabilities: []*csi.VolumeCapability{
			{
				AccessMode: &csi.VolumeCapability_AccessMode{
					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
				},
			},
		},
	}

	resp, err := cs.ValidateVolumeCapabilities(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.NotNil(t, resp.Confirmed)
}

func TestValidateVolumeCapabilitiesVolumeIdMissing(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.ValidateVolumeCapabilitiesRequest{
		VolumeCapabilities: []*csi.VolumeCapability{
			{
				AccessMode: &csi.VolumeCapability_AccessMode{
					Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
				},
			},
		},
	}

	_, err := cs.ValidateVolumeCapabilities(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
}

func TestValidateVolumeCapabilitiesCapabilitiesMissing(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.ValidateVolumeCapabilitiesRequest{
		VolumeId: "vol-1",
	}

	_, err := cs.ValidateVolumeCapabilities(context.Background(), req)
	require.Error(t, err)
	assert.Equal(t, codes.InvalidArgument, getErrorCode(err))
}

func TestControllerGetCapabilities(t *testing.T) {
	fakeStorage := &controllerStorageManager{fakeStorageManager: newFakeStorageManager()}
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(fakeStorage, fakePVCReader)

	req := &csi.ControllerGetCapabilitiesRequest{}
	resp, err := cs.ControllerGetCapabilities(context.Background(), req)
	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Len(t, resp.Capabilities, 1)
	assert.Equal(t, csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME, resp.Capabilities[0].GetRpc().Type)
}

func TestReadPVCAnnotationsWithPVCInfo(t *testing.T) {
	fakePVCReader := &fakePVCReader{
		annotations: map[string]string{
			pvcKeyLbaFormat: "1",
		},
	}
	cs := NewControllerServer(&controllerStorageManager{fakeStorageManager: newFakeStorageManager()}, fakePVCReader)

	params := map[string]string{
		pvcNameKey:      "my-pvc",
		pvcNamespaceKey: "my-namespace",
	}

	annotations, err := cs.readPVCAnnotations(context.Background(), params)
	require.NoError(t, err)
	assert.Equal(t, map[string]string{pvcKeyLbaFormat: "1"}, annotations)
}

func TestReadPVCAnnotationsWithoutPVCInfo(t *testing.T) {
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(&controllerStorageManager{fakeStorageManager: newFakeStorageManager()}, fakePVCReader)

	params := map[string]string{} // 没有 PVC name 和 namespace

	annotations, err := cs.readPVCAnnotations(context.Background(), params)
	require.NoError(t, err)
	assert.Nil(t, annotations)
}

func TestReadPVCAnnotationsOnlyName(t *testing.T) {
	fakePVCReader := &fakePVCReader{}
	cs := NewControllerServer(&controllerStorageManager{fakeStorageManager: newFakeStorageManager()}, fakePVCReader)

	params := map[string]string{
		pvcNameKey: "my-pvc",
	}

	annotations, err := cs.readPVCAnnotations(context.Background(), params)
	require.NoError(t, err)
	assert.Nil(t, annotations) // 需要 name 和 namespace 都存在
}