import { ManagementClient } from './ManagementClient';
import { getOptionsFromEnv } from '../testing-helper';
import test from 'ava';
import { generateRandomString } from '../utils';
import { PolicyAssignmentTargetType, ResourceType } from '../..';

const managementClient = new ManagementClient(getOptionsFromEnv());

// 初始化数据
const initData = async () => {
  // 创建 namespace
  const namespaceCode = generateRandomString();
  const namespaceName = generateRandomString();
  const namespace = await managementClient.acl.createNamespace(
    namespaceCode,
    namespaceName
  );

  // 创建用户
  const user = await managementClient.users.create({
    username: generateRandomString(30)
  });

  // 创建角色
  const roleCode = generateRandomString();
  const role = await managementClient.roles.create(
    roleCode,
    '',
    namespace.code
  );

  // 创建组织机构
  const org = await managementClient.org.create(
    generateRandomString(),
    generateRandomString()
  );

  // 创建分组
  const group = await managementClient.groups.create(
    generateRandomString(),
    generateRandomString()
  );

  // 创建资源
  const resource = await managementClient.acl.createResource({
    namespace: namespace.code,
    code: 'ec2',
    type: 'DATA',
    description: '服务器',
    actions: [
      {
        name: 'ec2:Start',
        description: '启动服务器'
      },
      {
        name: 'ec2:Delete',
        description: '删除服务器'
      },
      {
        name: 'ec2:Release',
        description: '释放服务器'
      },
      {
        name: 'ec2:Restart',
        description: '重启服务器'
      },
      {
        name: 'ec2:UpdateBasicInformation',
        description: '修改服务器基础描述信息'
      },
      {
        name: 'ec2:ViewMonitoringStatistics',
        description: '查看服务器监控信息'
      }
    ]
  });

  return {
    namespace,
    role,
    user,
    org,
    group,
    resource
  };
};

test('AclManagementClient.authorizeResources', async t => {
  const { namespace, user, group, role, org, resource } = await initData();

  await managementClient.acl.authorizeResources({
    namespace: namespace.code,
    opts: [
      {
        targetType: PolicyAssignmentTargetType.User,
        targetIdentifiers: [user.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Start'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Group,
        targetIdentifiers: [group.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Stop'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Role,
        targetIdentifiers: [role.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:UpdateBasicInformation'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Org,
        targetIdentifiers: [org.rootNode.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:ViewMonitoringStatistics'],
            resourceType: ResourceType.Data
          }
        ]
      }
    ]
  });

  const isAllowed1 = await managementClient.acl.isAllowed(
    user.id,
    'ec2:1',
    'ec2:Start',
    {
      namespace: namespace.code
    }
  );

  t.assert(isAllowed1);
});

test.only('AclManagementClient.listAuthorizedResourcesBatch', async t => {
  const { namespace, user, group, role, org, resource } = await initData();
  await managementClient.acl.authorizeResources({
    namespace: namespace.code,
    opts: [
      {
        targetType: PolicyAssignmentTargetType.User,
        targetIdentifiers: [user.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Start'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Group,
        targetIdentifiers: [group.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Stop'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Role,
        targetIdentifiers: [role.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:UpdateBasicInformation'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Org,
        targetIdentifiers: [org.rootNode.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:ViewMonitoringStatistics'],
            resourceType: ResourceType.Data
          }
        ]
      }
    ]
  });

  const { list } = await managementClient.acl.listAuthorizedResourcesBatch({
    namespace: namespace.code,
    targets: [
      {
        targetType: PolicyAssignmentTargetType.User,
        targetIdentifier: user.id
      },
      {
        targetType: PolicyAssignmentTargetType.Group,
        targetIdentifier: group.code
      },
      {
        targetType: PolicyAssignmentTargetType.Role,
        targetIdentifier: role.code
      },
      {
        targetType: PolicyAssignmentTargetType.Org,
        targetIdentifier: org.rootNode.id
      }
    ]
  });

  t.assert(list[0].list[0].code === 'ec2:1');
  t.assert(list[0].list[0].actions.includes('ec2:Start'));
  t.assert(list[1].list[0].code === 'ec2:1');
  t.assert(list[1].list[0].actions.includes('ec2:Stop'));
  t.assert(list[2].list[0].code === 'ec2:1');
  t.assert(list[2].list[0].actions.includes('ec2:UpdateBasicInformation'));
  t.assert(list[3].list[0].code === 'ec2:1');
  t.assert(list[3].list[0].actions.includes('ec2:ViewMonitoringStatistics'));
});

test('getPoliciesAssignmentsCondition', async t => {
  const result = await managementClient.acl.getPoliciesAssignmentsCondition("default","wIHHgw9zG","ROLE");
  console.log(result)
  t.assert(result != null );
});


test('AclManagementClient.revokeResources', async t => {
  const { namespace, user, group, role, org, resource } = await initData();
  await managementClient.acl.authorizeResources({
    namespace: namespace.code,
    opts: [
      {
        targetType: PolicyAssignmentTargetType.User,
        targetIdentifiers: [user.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Start'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Group,
        targetIdentifiers: [group.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Stop'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Role,
        targetIdentifiers: [role.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:UpdateBasicInformation'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Org,
        targetIdentifiers: [org.rootNode.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:ViewMonitoringStatistics'],
            resourceType: ResourceType.Data
          }
        ]
      }
    ]
  });
  await managementClient.acl.revokeResources({
    namespace: namespace.code,
    opts: [
      {
        targetType: PolicyAssignmentTargetType.User,
        targetIdentifiers: [user.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Start'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Group,
        targetIdentifiers: [group.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:Stop'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Role,
        targetIdentifiers: [role.code],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:UpdateBasicInformation'],
            resourceType: ResourceType.Data
          }
        ]
      },
      {
        targetType: PolicyAssignmentTargetType.Org,
        targetIdentifiers: [org.rootNode.id],
        resources: [
          {
            code: `${resource.code}:1`,
            actions: ['ec2:ViewMonitoringStatistics'],
            resourceType: ResourceType.Data
          }
        ]
      }
    ]
  });

  const isAllowed1 = await managementClient.acl.isAllowed(
    user.id,
    'ec2:1',
    'ec2:Start',
    {
      namespace: namespace.code
    }
  );

  t.assert(isAllowed1 === false);
});