Feature: Feature Name
  As a [role]
  I want [feature]
  So that [benefit]

  Background:
    Given some precondition that applies to all scenarios

  Scenario: Scenario name
    Given some initial context
    When an action is performed
    Then an expected outcome occurs

  Scenario Outline: Parameterized scenario
    Given a user with <role> role
    When they access <page>
    Then they should see <expected>

    Examples:
      | role    | page       | expected        |
      | student | /dashboard | "My Courses"    |
      | writer  | /dashboard | "Create Course" |

import { Given, When, Then } from '@cucumber/cucumber';
import { expect } from '@playwright/test';
import { getPage } from '../support/world';

Given('I am on the login page', async function () {
  const page = getPage(this);
  await page.goto('/login');
});

When('I enter valid credentials', async function () {
  const page = getPage(this);
  await page.getByLabel('Email').fill('user@example.com');
  await page.getByLabel('Password').fill('password123');
  await page.getByRole('button', { name: 'Login' }).click();
});

Then('I should see the dashboard', async function () {
  const page = getPage(this);
  await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible();
});

Given('I am logged in as a {string} user', async function (role: string) {
  const page = getPage(this);
  // Login with role-specific credentials
  await loginAs(page, role);
});

When('I navigate to {string}', async function (path: string) {
  const page = getPage(this);
  await page.goto(path);
});

Then('I should see {int} atoms in the endpoint', async function (count: number) {
  const page = getPage(this);
  await expect(page.locator('[data-testid="atom"]')).toHaveCount(count);
});

Scenario: Create a course with endpoints
  Given I am logged in as a writer
  When I create a course with the following endpoints:
    | name              | passThreshold |
    | HTML Fundamentals | 50            |
    | CSS Basics        | 60            |
  Then the course should have 2 endpoints

When('I create a course with the following endpoints:', async function (dataTable) {
  const page = getPage(this);
  const endpoints = dataTable.hashes(); // [{name: 'HTML...', passThreshold: '50'}, ...]

  for (const endpoint of endpoints) {
    await page.getByRole('button', { name: 'Add Endpoint' }).click();
    await page.getByLabel('Endpoint Name').fill(endpoint.name);
    await page.getByLabel('Pass Threshold').fill(endpoint.passThreshold);
    await page.getByRole('button', { name: 'Save' }).click();
  }
});

Feature: User Authentication
  As a user
  I want to log in to my organization
  So that I can access the learning platform

  Background:
    Given an organization "test-org" exists
    And a student user exists in the organization

  Scenario: Successful login
    Given I am on the login page for "test-org"
    When I enter valid credentials
    And I click the login button
    Then I should be redirected to the dashboard
    And I should see a welcome message

  Scenario: Failed login with wrong password
    Given I am on the login page for "test-org"
    When I enter an invalid password
    And I click the login button
    Then I should see an error message "Invalid credentials"
    And I should remain on the login page

  Scenario Outline: Role-based dashboard
    Given I am logged in as a <role> user
    When I view the dashboard
    Then I should see <section>

    Examples:
      | role    | section          |
      | student | "My Learning"    |
      | writer  | "My Courses"     |
      | admin   | "Organization"   |

Feature: Adaptive Learning Flow
  As a student
  I want the system to adapt to my learning
  So that I can learn more effectively

  Background:
    Given I am enrolled in a course "Frontend Developer"
    And the course has an endpoint "HTML Basics" with 5 atoms

  Scenario: Complete atom successfully
    Given I am on atom 1 of endpoint "HTML Basics"
    When I read the atom content
    And I answer the assessment correctly
    Then I should see a success message
    And I should proceed to atom 2

  Scenario: Fail atom and get AI assistance
    Given I am on atom 3 of endpoint "HTML Basics"
    When I read the atom content
    And I answer the assessment incorrectly
    Then the AI chat assistant should open
    And I should see an explanation of the concept
    When I ask a question about the concept
    Then I should receive a helpful response
    When I retry the assessment and answer correctly
    Then the chat should close
    And I should proceed to atom 4

  Scenario: Fail endpoint and receive injected atoms
    Given I have completed endpoint "HTML Basics" with 40% score
    And the pass threshold is 50%
    Then the system should analyze my knowledge gaps
    And inject additional atoms into the endpoint
    When I view the endpoint
    Then I should see the injected atoms
    And the atoms should be contextually relevant

Feature: AI-Assisted Course Creation
  As a writer
  I want to upload materials and have AI generate a course
  So that I can create courses without manual structuring

  Scenario: Upload materials and generate course structure
    Given I am logged in as a writer
    And I am on the course creation page
    When I upload the following materials:
      | type  | file                    |
      | pdf   | web-development.pdf     |
      | video | intro-to-html.mp4       |
    And I click "Analyze Materials"
    Then I should see a loading indicator
    When the analysis completes
    Then I should see a proposed course structure
    And the structure should include endpoints
    And each endpoint should contain atoms

  Scenario: Customize pass threshold
    Given I have a proposed course structure
    When I set the pass threshold for "HTML Basics" to 70%
    And I publish the course
    Then students enrolling should have 70% pass requirement for that endpoint

# Run all tests
npx playwright test

# Run specific feature file
npx playwright test tests/e2e/features/auth.feature

# Run tests with specific tag
npx playwright test --grep @smoke

# Run in UI mode
npx playwright test --ui

# Debug mode
npx playwright test --debug

# Generate HTML report
npx playwright test --reporter=html

@smoke
Feature: Critical Path Tests

@wip
Scenario: Work in progress test

@slow
Scenario: Long-running test

@api
Scenario: API-only test