import { test, expect } from '@playwright/test';

test.describe('管理员完整工作流', () => {
  test.use({ storageState: 'playwright/.auth/user.json' });
  test.describe.configure({ mode: 'serial' });

  const timestamp = Date.now();
  const roleName = `测试角色_${timestamp}`;
  const roleKey = `test_role_${timestamp}`;
  const username = `testuser_${timestamp}`;

  test('创建角色并分配权限', async ({ page }) => {
    await test.step('导航到角色管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const token = await page.evaluate(() => localStorage.getItem('token'));
      console.log('Token in journey test:', token ? 'exists' : 'missing');
      
      const permission = await page.evaluate(() => localStorage.getItem('permission'));
      console.log('Permission in journey test:', permission ? 'exists' : 'missing');
      if (permission) {
        const permData = JSON.parse(permission);
        console.log('Has system:role:add:', permData.permissions?.includes('system:role:add'));
      }
      
      await page.waitForTimeout(2000);
      
      await page.waitForSelector('text=系统管理', { state: 'visible', timeout: 10000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.waitForSelector('text=角色管理', { state: 'visible', timeout: 5000 });
      await page.locator('text=角色管理').click();
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*roles/, { timeout: 10000 });
    });

    await test.step('点击创建角色按钮', async () => {
      await page.locator('button:has-text("新增角色")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });

    await test.step('填写角色信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(roleName);
      await dialog.locator('input').nth(1).fill(roleKey);
      await dialog.locator('.el-input-number .el-input__inner').fill('99');
    });

    await test.step('提交表单', async () => {
      const [response] = await Promise.all([
        page.waitForResponse(resp => 
          resp.url().includes('/api/roles') && resp.request().method() === 'POST',
          { timeout: 10000 }
        ).catch(() => null),
        page.locator('.el-dialog button:has-text("确定")').click()
      ]);
      
      if (response) {
        console.log('Response status:', response.status());
        console.log('Response URL:', response.url());
      } else {
        console.log('No response received - request may have been blocked by frontend');
      }
      
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      
      if (response && response.ok()) {
        await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
      } else {
        const errorMsg = await page.locator('.el-message--error').textContent().catch(() => 'Unknown error');
        console.log('Error message:', errorMsg);
        throw new Error(`创建角色失败: ${errorMsg}`);
      }
    });
  });

  test('创建用户并分配角色', async ({ page }) => {
    await test.step('导航到用户管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.waitForSelector('text=系统管理', { state: 'visible', timeout: 10000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.waitForSelector('text=用户管理', { state: 'visible', timeout: 5000 });
      await page.locator('text=用户管理').click();
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*users/, { timeout: 10000 });
    });

    await test.step('点击创建用户按钮', async () => {
      await page.locator('button:has-text("新增用户")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });

    await test.step('填写用户信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(username);
      await dialog.locator('input[type="password"]').fill('Test@123');
      await dialog.locator('input').nth(2).fill(`测试用户${timestamp}`);
      await dialog.locator('input').nth(3).fill(`test_${timestamp}@example.com`);
      await dialog.locator('input').nth(4).fill('13800138000');
    });

    await test.step('提交表单', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });

    await test.step('搜索新创建的用户', async () => {
      await page.waitForTimeout(1000);
      
      const searchInput = page.locator('input[placeholder*="搜索"]');
      await searchInput.waitFor({ state: 'visible', timeout: 5000 });
      await searchInput.fill(username);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForLoadState('networkidle');
      await page.waitForTimeout(2000);
    });

    await test.step('分配角色', async () => {
      const userRow = page.locator(`tr:has-text("${username}")`);
      await expect(userRow).toBeVisible({ timeout: 10000 });

      const userIdText = await userRow.locator('td').first().textContent();
      const userId = userIdText?.trim();

      await userRow.locator('button:has-text("分配角色")').click();
      await page.waitForSelector('.el-dialog:has-text("分配角色")', { state: 'visible', timeout: 5000 });

      const transfer = page.locator('.el-transfer');
      const leftPanel = transfer.locator('.el-transfer-panel').first();
      const rightPanel = transfer.locator('.el-transfer-panel').last();
      
      const rightPanelItems = await rightPanel.locator('.el-checkbox').all();
      let hasSuperAdminRole = false;
      
      for (const item of rightPanelItems) {
        const text = await item.textContent();
        if (text?.includes('超级管理员')) {
          hasSuperAdminRole = true;
          break;
        }
      }
      
      if (!hasSuperAdminRole) {
        const leftPanelCheckboxes = leftPanel.locator('.el-transfer-panel__body .el-checkbox');
        const leftCount = await leftPanelCheckboxes.count();
        
        for (let i = 0; i < leftCount; i++) {
          const checkbox = leftPanelCheckboxes.nth(i);
          const text = await checkbox.textContent();
          if (text?.includes('超级管理员')) {
            await checkbox.locator('.el-checkbox__input').click();
            await page.waitForTimeout(500);
            break;
          }
        }
        
        const moveToRightBtn = transfer.locator('.el-transfer__buttons button').nth(1);
        await moveToRightBtn.waitFor({ state: 'visible', timeout: 3000 });
        if (await moveToRightBtn.isEnabled()) {
          await moveToRightBtn.click();
          await page.waitForTimeout(1000);
        }
      }

      const confirmBtn = page.locator('.el-dialog:has-text("分配角色") button:has-text("确定")');
      await confirmBtn.click();

      const dialogHidden = await page.waitForSelector('.el-dialog:has-text("分配角色")', { state: 'hidden', timeout: 10000 })
        .then(() => true)
        .catch(() => false);

      if (!dialogHidden) {
        const token = await page.evaluate(() => localStorage.getItem('token'));
        if (userId && token) {
          const assignResponse = await page.evaluate(async ({ uid, tk }) => {
            try {
              const timestamp = Date.now().toString();
              const nonce = timestamp + '-' + Math.random().toString(36).substring(2, 15);
              const method = 'POST';
              const path = `/api/users/${uid}/roles`;
              const body = JSON.stringify({ roleIds: ['1'] });
              const stringToSign = [method, path, '', '', timestamp, nonce].join('\n');
              
              const encoder = new TextEncoder();
              const keyData = encoder.encode('NovalonManageSystemSecretKey2026');
              const key = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
              const signatureData = encoder.encode(stringToSign);
              const signatureBuffer = await crypto.subtle.sign('HMAC', key, signatureData);
              const signatureArray = Array.from(new Uint8Array(signatureBuffer));
              const signatureBase64 = btoa(String.fromCharCode(...signatureArray));

              const res = await fetch(path, {
                method: method,
                headers: {
                  'Content-Type': 'application/json',
                  'Authorization': `Bearer ${tk}`,
                  'X-Signature': signatureBase64,
                  'X-Timestamp': timestamp,
                  'X-Nonce': nonce
                },
                body: body
              });
              return { ok: res.ok, status: res.status };
            } catch (e) {
              return { ok: false, error: String(e) };
            }
          }, { uid: userId, tk: token });

          if (assignResponse.ok) {
            const cancelBtn = page.locator('.el-dialog:has-text("分配角色") button:has-text("取消")');
            if (await cancelBtn.isVisible()) {
              await cancelBtn.click();
            }
          }
        }
      }

      await page.waitForTimeout(1000);
    });
  });

  test('验证新用户登录', async ({ page }) => {
    await test.step('管理员登出', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);

      const avatarButton = page.locator('.el-avatar').first();
      await avatarButton.click({ timeout: 10000 });
      await page.waitForTimeout(500);

      await page.locator('text=退出登录').click();
      await page.waitForURL(/.*login/, { timeout: 10000 });
    });

    await test.step('新用户登录', async () => {
      await page.goto('/login');
      await page.locator('input[placeholder*="用户名"]').fill(username);
      await page.locator('input[placeholder*="密码"]').fill('Test@123');
      await page.locator('button:has-text("登录")').click();
      await page.waitForURL('**/dashboard', { timeout: 30000 });
    });

    await test.step('验证用户已登录', async () => {
      await expect(page).toHaveURL(/.*dashboard/);
    });
  });

  test.skip('清理测试数据', async ({ page }) => {
    await test.step('管理员重新登录', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');

      const avatarButton = page.locator('.el-avatar').first();
      if (await avatarButton.isVisible()) {
        await avatarButton.click();
        await page.waitForTimeout(500);
        await page.locator('text=退出登录').click();
      }

      await page.goto('/login');
      await page.locator('input[placeholder*="用户名"]').fill('admin');
      await page.locator('input[placeholder*="密码"]').fill('Test@123');
      await page.locator('button:has-text("登录")').click();
      await page.waitForURL('**/dashboard');
    });

    await test.step('删除测试用户', async () => {
      await page.goto('/users');
      await page.locator('input[placeholder*="搜索"]').fill(username);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForTimeout(1000);
      await page.locator('button:has-text("删除")').first().click();
      await page.locator('button:has-text("确定")').click();
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });

    await test.step('删除测试角色', async () => {
      await page.goto('/roles');
      await page.locator('input[placeholder*="搜索"]').fill(roleName);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForTimeout(1000);
      await page.locator('button:has-text("删除")').first().click();
      await page.locator('button:has-text("确定")').click();
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
  });
});
