scenario_generator.dart

import 'package:bdd_widget_test/src/bdd_line.dart';
import 'package:bdd_widget_test/src/step_generator.dart';
import 'package:bdd_widget_test/src/util/constants.dart';

void parseScenario(
  StringBuffer sb,
  String scenarioTitle,
  List<BddLine> scenario,
  bool hasSetUp,
  bool hasTearDown,
  bool hasHooks,
  String testMethodName,
  String testerName,
  List<String> tags,
  String scenarioParams,
) {
  sb.writeln(
    "    $testMethodName('''$scenarioTitle''', ($testerName) async {",
  );
  if (hasHooks) {
    sb.writeln('      var $testSuccessVariableName = true;');
  }
  if (hasTearDown || hasHooks) {
    sb.writeln('      try {');
  }
  final spaces = hasTearDown ? '        ' : '      ';
  if (hasHooks) {
    sb.writeln(
      "${spaces}await $setUpHookName('''$scenarioTitle''' ${tags.isNotEmpty ? ', ${tagsToString(tags)}' : ''});",
    );
  }
  if (hasSetUp) {
    sb.writeln('${spaces}await $setUpMethodName($testerName);');
  }

  for (final step in scenario) {
    sb.writeln('${spaces}await ${getStepMethodCall(step.value, testerName)};');
  }

  if (hasHooks) {
    sb.writeln('      } catch (_) {');
    sb.writeln('        $testSuccessVariableName = false;');
    sb.writeln('        rethrow;');
  }

  if (hasTearDown | hasHooks) {
    sb.writeln('      } finally {');
    if (hasTearDown) {
      sb.writeln('        await $tearDownMethodName($testerName);');
    }
    if (hasHooks) {
      sb.writeln('        await $tearDownHookName(');
      sb.writeln("          '''$scenarioTitle''',");
      sb.writeln('          $testSuccessVariableName,');
      if (tags.isNotEmpty) {
        sb.writeln('          ${tagsToString(tags)},');
      }
      sb.writeln('        );');
    }
    sb.writeln('      }');
  }

  sb.writeln(
    '    }${tags.isNotEmpty ? ", tags: ${tagsToString(tags)}" : ''}${scenarioParams.isNotEmpty ? ',' : ');'}',
  );
  if (scenarioParams.isNotEmpty) {
    for (final param in scenarioParams.split(', ')) {
      sb.writeln('     $param,');
    }
    sb.writeln(
      '     );',
    );
  }
}

String tagsToString(List<String> tags) {
  return "['${tags.join("', '")}']";
}

List<List<BddLine>> generateScenariosFromScenarioOutline(
  List<BddLine> scenario,
) {
  final examples = _getExamples(scenario);
  return examples
      .map((e) => _processScenarioLines(scenario, e).toList())
      .toList();
}

List<Map<String, String>> _getExamples(
  List<BddLine> scenario,
) {
  final exampleLines = scenario
      .skipWhile((l) => l.type != LineType.exampleTitle)
      .where((l) => l.type == LineType.examples)
      .map(
        (e) => e.rawLine.substring(
          // Remove the first and the last '|' separator
          1,
          e.rawLine.length - 1,
        ),
      )
      .map(_parseExampleLine);
  final names = exampleLines.first;
  return exampleLines.skip(1).map((e) => Map.fromIterables(names, e)).toList();
}

List<String> _parseExampleLine(String line) =>
    line.split('|').map((e) => e.trim()).toList();

Iterable<BddLine> _processScenarioLines(
  List<BddLine> lines,
  Map<String, String> examples,
) sync* {
  final name = lines.first;
  yield BddLine.fromValue(
    name.type,
    '${name.value} (${examples.values.join(', ')})',
  );

  for (final line in lines.skip(1)) {
    yield BddLine.fromValue(
      line.type,
      _replacePlaceholders(
        line.value,
        line.type == LineType.dataTableStep,
        examples,
      ),
    );
  }
}

String _replacePlaceholders(
  String line,
  bool isDataTableStep,
  Map<String, String> example,
) {
  // For data table steps, we want placeholders in the step text
  // to become parameters (wrapped with {}), but placeholders inside the
  // DataTable argument should be inlined as raw values.
  if (isDataTableStep) {
    const marker = '{const bdd.DataTable(';
    final dataTableIndex = line.indexOf(marker);
    if (dataTableIndex != -1) {
      final head = line.substring(0, dataTableIndex);
      final tail = line.substring(dataTableIndex);
      var headReplaced = head;
      var tailReplaced = tail;
      for (final e in example.keys) {
        headReplaced = headReplaced.replaceAll('<$e>', '{${example[e]}}');
        tailReplaced = tailReplaced.replaceAll('<$e>', '${example[e]}');
      }
      return headReplaced + tailReplaced;
    }
  }

  return _replacePlaceholdersWithContext(line, example);
}

// Placeholders inside {} blocks become raw values,
// Placeholders outside {} blocks become parameters (wrapped with {})
String _replacePlaceholdersWithContext(
  String line,
  Map<String, String> example,
) {
  final result = StringBuffer();
  var i = 0;
  var braceDepth = 0;

  while (i < line.length) {
    // Track brace depth to know if we're inside a parameter block
    if (line[i] == '{') {
      braceDepth++;
      result.write('{');
      i++;
    } else if (line[i] == '}') {
      braceDepth--;
      result.write('}');
      i++;
    } else if (line[i] == '<') {
      // Check if this is a placeholder
      var foundPlaceholder = false;
      for (final key in example.keys) {
        final placeholder = '<$key>';
        if (i + placeholder.length <= line.length &&
            line.substring(i, i + placeholder.length) == placeholder) {
          // Found a placeholder
          if (braceDepth > 0) {
            // Inside a parameter block - use raw value
            result.write(example[key]);
          } else {
            // Outside parameter blocks - wrap with {}
            result.write('{${example[key]}}');
          }
          i += placeholder.length;
          foundPlaceholder = true;
          break;
        }
      }
      if (!foundPlaceholder) {
        result.write(line[i]);
        i++;
      }
    } else {
      result.write(line[i]);
      i++;
    }
  }

  return result.toString();
}