import 'dart:io';

import 'package:swagger_generator_flutter/core/config_repository.dart';
import 'package:swagger_generator_flutter/utils/string_helper.dart';
import 'package:test/test.dart';

void main() {
  group('Model Class Prefix Support', () {
    late Directory tempDir;
    late File configFile;

    setUp(() {
      tempDir = Directory.systemTemp.createTempSync('swagger_gen_test_');
      configFile = File('${tempDir.path}/generator_config.yaml');
    });

    tearDown(() {
      tempDir.deleteSync(recursive: true);
    });

    test('should parse class_prefix from config', () {
      configFile.writeAsStringSync('''
generator:
  name: test
  
output:
  models:
    class_prefix: "MyPrefix"

generation:
  models:
    class_prefix: "MyPrefix"
''');

      final config = ConfigRepository.loadSync(configFile.path);
      expect(config.modelClassPrefix, equals('MyPrefix'));
    });

    test('should return null when class_prefix is missing', () {
      configFile.writeAsStringSync('''
generator:
  name: test
''');

      final config = ConfigRepository.loadSync(configFile.path);
      expect(config.modelClassPrefix, isNull);
    });

    test('should apply class_prefix using StringHelper.generateClassName', () {
      configFile.writeAsStringSync('''
generator:
  name: test
  
output:
  models:
    class_prefix: "S"

generation:
  models:
    class_prefix: "S"
''');

      // Reload config to ensure StringHelper picks up the new prefix
      // This relies on SwaggerConfig.modelClassPrefix internally calling ConfigRepository.loadSync()
      // which will find the config file in the current working directory (or tempDir in this test context).
      // For this test to work, the test runner's CWD must be tempDir, or PathResolver must be mocked.
      // Assuming PathResolver.findConfigFile() correctly finds the temp file.

      // The current implementation of StringHelper.generateClassName relies on SwaggerConfig.modelClassPrefix
      // which in turn calls ConfigRepository.loadSync() without arguments.
      // This means it will try to find the config file in the current working directory or via PathResolver.
      // For this test to pass, the `configFile` must be discoverable by `ConfigRepository.loadSync()`.
      // This test implicitly relies on the test environment's CWD or PathResolver setup.

      // To make this test robust, StringHelper should ideally take a Config object or
      // SwaggerConfig should have a way to inject a test config.
      // For now, we proceed with the assumption that `ConfigRepository.loadSync()` will find `configFile`.

      // Force a reload of the static config by accessing it.
      // This is a bit of a hack due to the static nature of SwaggerConfig and StringHelper.
      // A better approach would be to pass the config explicitly or mock the static dependencies.
      // Load config and set it as cached so static accessors pick it up
      final config = ConfigRepository.loadSync(configFile.path);
      ConfigRepository.setCachedConfig(config);

      expect(StringHelper.generateClassName('User'), 'SUser');
      expect(StringHelper.generateClassName('model'), 'SModel');
      // Test case: prefix is 'S' and name starts with 'S'
      expect(StringHelper.generateClassName('SubjectInfo'), 'SSubjectInfo');
    });

    // NOTE: Testing StringHelper.generateClassName directly implies checking if it reads from the GLOBAL config.
    // However, ConfigRepository.loadSync() creates an instance, but SwaggerConfig accessors call ConfigRepository.loadSync() individually.
    // Since ConfigRepository.loadSync() without args looks for default file, we need a way to inject the config or point it to our file.
    // The current implementation of SwaggerConfig calls ConfigRepository.loadSync() which defaults to finding a config file.

    // Changing the implementation of StringHelper to depend on a reloadable config or global state would be better,
    // but without changing that, we rely on how ConfigRepository finds the file.
    // Ideally we should test ConfigRepository logic separately from StringHelper if StringHelper uses a static/global config lookup.

    // BUT, wait. ConfigRepository.loadSync() does THIS:
    // final file = File(configPath ?? PathResolver.findConfigFile() ?? '');

    // If we want SwaggerConfig (static) to pick up our test config, we might need to trick PathResolver
    // OR we can explicitly pass the config path if the code supported it, but StringHelper uses static SwaggerConfig.modelClassPrefix.

    // The current implementation of `SwaggerConfig.modelClassPrefix` is:
    // static String? get modelClassPrefix => ConfigRepository.loadSync().modelClassPrefix;

    // So every time we call `StringHelper.generateClassName`, it calls `ConfigRepository.loadSync()`.
    // `ConfigRepository.loadSync()` calls `PathResolver.findConfigFile()`.

    // Since we cannot easily mock `PathResolver`'s static method or filesystem search path in a unit test without dependency injection,
    // we might face issues testing `StringHelper` integration end-to-end here unless we run this test in a context where `findConfigFile` returns our temp file.

    // However, for verify purposes, verifying `ConfigRepository` parses it is the most critical part we added.
    // The `StringHelper` logic is simple string concatenation.
  });
}