import 'package:test/test.dart';

import '../lib/core/models.dart';

void main() {
  group('ApiPath', () {
    test('creates ApiPath with required fields', () {
      final path = ApiPath(
        path: '/api/users',
        method: HttpMethod.get,
        summary: 'Get users',
        description: 'Retrieve all users',
        operationId: 'getUsers',
        tags: ['User'],
        parameters: [],
        responses: {},
        requestBody: null,
      );

      expect(path.path, '/api/users');
      expect(path.method, HttpMethod.get);
      expect(path.summary, 'Get users');
      expect(path.description, 'Retrieve all users');
      expect(path.tags, ['User']);
      expect(path.parameters, isEmpty);
      expect(path.responses, isEmpty);
      expect(path.requestBody, isNull);
    });

    test('creates ApiPath with all fields', () {
      final parameters = [
        ApiParameter(
          name: 'id',
          location: ParameterLocation.path,
          required: true,
          type: PropertyType.integer,
          description: 'User ID',
        ),
      ];

      final responses = {
        '200': ApiResponse(
          code: '200',
          description: 'Success',
          schema: {'type': 'object'},
          content: null,
        ),
      };

      final requestBody = ApiRequestBody(
        description: 'User data',
        required: true,
        content: {
          'application/json': {
            'schema': {'type': 'object'}
          }
        },
      );

      final path = ApiPath(
        path: '/api/users/{id}',
        method: HttpMethod.put,
        summary: 'Update user',
        description: 'Update user by ID',
        operationId: 'updateUser',
        tags: ['User'],
        parameters: parameters,
        responses: responses,
        requestBody: requestBody,
      );

      expect(path.parameters, hasLength(1));
      expect(path.responses, hasLength(1));
      expect(path.requestBody, isNotNull);
    });
  });

  group('ApiParameter', () {
    test('creates ApiParameter with required fields', () {
      final param = ApiParameter(
        name: 'id',
        location: ParameterLocation.path,
        required: true,
        type: PropertyType.integer,
        description: 'User ID',
      );

      expect(param.name, 'id');
      expect(param.location, ParameterLocation.path);
      expect(param.required, true);
      expect(param.type, PropertyType.integer);
      expect(param.description, 'User ID');
    });

    test('creates ApiParameter with optional fields', () {
      final param = ApiParameter(
        name: 'page',
        location: ParameterLocation.query,
        required: false,
        type: PropertyType.integer,
        description: 'Page number',
        format: 'int32',
        example: 1,
        defaultValue: 1,
      );

      expect(param.format, 'int32');
      expect(param.example, 1);
      expect(param.defaultValue, 1);
    });

    test('creates ApiParameter from JSON', () {
      final json = {
        'name': 'id',
        'in': 'path',
        'required': true,
        'type': 'integer',
        'description': 'User ID',
        'format': 'int64',
        'example': 123,
        'default': 1,
      };

      final param = ApiParameter.fromJson(json);

      expect(param.name, 'id');
      expect(param.location, ParameterLocation.path);
      expect(param.required, true);
      expect(param.type, PropertyType.integer);
      expect(param.description, 'User ID');
      expect(param.format, 'int64');
      expect(param.example, 123);
      expect(param.defaultValue, 1);
    });
  });

  group('ApiResponse', () {
    test('creates ApiResponse with required fields', () {
      final response = ApiResponse(
        code: '200',
        description: 'Success',
        schema: null,
        content: null,
      );

      expect(response.code, '200');
      expect(response.description, 'Success');
      expect(response.schema, isNull);
      expect(response.content, isNull);
    });

    test('creates ApiResponse with schema', () {
      final schema = {
        'type': 'object',
        'properties': {
          'id': {'type': 'integer'},
          'name': {'type': 'string'},
        },
      };

      final response = ApiResponse(
        code: '200',
        description: 'Success',
        schema: schema,
        content: null,
      );

      expect(response.schema, equals(schema));
    });

    test('creates ApiResponse from JSON', () {
      final json = {
        'description': 'Success',
        'schema': {'type': 'object'},
        'content': {
          'application/json': {
            'schema': {'type': 'object'},
          },
        },
      };

      final response = ApiResponse.fromJson('200', json);

      expect(response.code, '200');
      expect(response.description, 'Success');
      expect(response.schema, isNotNull);
      expect(response.content, isNotNull);
    });
  });

  group('ApiRequestBody', () {
    test('creates ApiRequestBody with required fields', () {
      final requestBody = ApiRequestBody(
        description: 'User data',
        required: true,
        content: null,
      );

      expect(requestBody.description, 'User data');
      expect(requestBody.required, true);
      expect(requestBody.content, isNull);
    });

    test('creates ApiRequestBody with content', () {
      final content = {
        'application/json': {
          'schema': {
            'type': 'object',
            'properties': {
              'name': {'type': 'string'},
              'email': {'type': 'string'},
            },
          },
        },
      };

      final requestBody = ApiRequestBody(
        description: 'User data',
        required: true,
        content: content,
      );

      expect(requestBody.content, equals(content));
    });

    test('creates ApiRequestBody from JSON', () {
      final json = {
        'description': 'User data',
        'required': true,
        'content': {
          'application/json': {
            'schema': {'type': 'object'},
          },
        },
      };

      final requestBody = ApiRequestBody.fromJson(json);

      expect(requestBody.description, 'User data');
      expect(requestBody.required, true);
      expect(requestBody.content, isNotNull);
    });
  });

  group('ApiModel', () {
    test('creates ApiModel with required fields', () {
      final model = ApiModel(
        name: 'User',
        description: 'User model',
        properties: {},
        required: [],
      );

      expect(model.name, 'User');
      expect(model.description, 'User model');
      expect(model.properties, isEmpty);
      expect(model.required, isEmpty);
      expect(model.isEnum, false);
      expect(model.enumValues, isEmpty);
      expect(model.enumType, isNull);
    });

    test('creates ApiModel with properties', () {
      final properties = {
        'id': ApiProperty(
          name: 'id',
          type: PropertyType.integer,
          description: 'User ID',
          required: true,
        ),
        'name': ApiProperty(
          name: 'name',
          type: PropertyType.string,
          description: 'User name',
          required: true,
        ),
      };

      final model = ApiModel(
        name: 'User',
        description: 'User model',
        properties: properties,
        required: ['id', 'name'],
      );

      expect(model.properties, hasLength(2));
      expect(model.required, ['id', 'name']);
    });

    test('creates enum ApiModel', () {
      final model = ApiModel(
        name: 'UserStatus',
        description: 'User status enum',
        properties: {},
        required: [],
        isEnum: true,
        enumValues: ['active', 'inactive', 'pending'],
        enumType: PropertyType.string,
      );

      expect(model.isEnum, true);
      expect(model.enumValues, ['active', 'inactive', 'pending']);
      expect(model.enumType, PropertyType.string);
    });

    test('creates ApiModel from JSON', () {
      final json = {
        'description': 'User model',
        'properties': {
          'id': {
            'type': 'integer',
            'description': 'User ID',
          },
          'name': {
            'type': 'string',
            'description': 'User name',
          },
        },
        'required': ['id', 'name'],
      };

      final model = ApiModel.fromJson('User', json);

      expect(model.name, 'User');
      expect(model.description, 'User model');
      expect(model.properties, hasLength(2));
      expect(model.required, ['id', 'name']);
    });

    test('creates enum ApiModel from JSON', () {
      final json = {
        'description': 'User status enum',
        'enum': ['active', 'inactive', 'pending'],
        'type': 'string',
      };

      final model = ApiModel.fromJson('UserStatus', json);

      expect(model.isEnum, true);
      expect(model.enumValues, ['active', 'inactive', 'pending']);
      expect(model.enumType, PropertyType.string);
    });
  });

  group('ApiProperty', () {
    test('creates ApiProperty with required fields', () {
      final property = ApiProperty(
        name: 'id',
        type: PropertyType.integer,
        description: 'User ID',
        required: true,
      );

      expect(property.name, 'id');
      expect(property.type, PropertyType.integer);
      expect(property.description, 'User ID');
      expect(property.required, true);
      expect(property.nullable, false);
    });

    test('creates ApiProperty with optional fields', () {
      final property = ApiProperty(
        name: 'name',
        type: PropertyType.string,
        description: 'User name',
        required: false,
        nullable: true,
        format: 'string',
        example: 'John Doe',
        defaultValue: 'Unknown',
        reference: 'User',
      );

      expect(property.nullable, true);
      expect(property.format, 'string');
      expect(property.example, 'John Doe');
      expect(property.defaultValue, 'Unknown');
      expect(property.reference, 'User');
    });

    test('creates ApiProperty from JSON', () {
      final json = {
        'type': 'string',
        'description': 'User name',
        'nullable': true,
        'format': 'string',
        'example': 'John Doe',
        'default': 'Unknown',
      };

      final property = ApiProperty.fromJson('name', json, []);

      expect(property.name, 'name');
      expect(property.type, PropertyType.string);
      expect(property.description, 'User name');
      expect(property.nullable, true);
      expect(property.format, 'string');
      expect(property.example, 'John Doe');
      expect(property.defaultValue, 'Unknown');
    });

    test('creates ApiProperty with reference', () {
      final json = {
        'type': 'object',
        'description': 'User object',
        '\$ref': '#/components/schemas/User',
      };

      final property = ApiProperty.fromJson('user', json, []);

      expect(property.type, PropertyType.reference);
      expect(property.reference, 'User');
    });

    test('creates ApiProperty with array items', () {
      final json = {
        'type': 'array',
        'description': 'User list',
        'items': {
          'type': 'object',
          '\$ref': '#/components/schemas/User',
        },
      };

      final property = ApiProperty.fromJson('users', json, []);

      expect(property.type, PropertyType.array);
      expect(property.items, isNotNull);
      expect(property.items!.name, 'User');
    });
  });

  group('PropertyType', () {
    test('converts string to PropertyType', () {
      expect(PropertyType.fromString('string'), PropertyType.string);
      expect(PropertyType.fromString('integer'), PropertyType.integer);
      expect(PropertyType.fromString('number'), PropertyType.number);
      expect(PropertyType.fromString('boolean'), PropertyType.boolean);
      expect(PropertyType.fromString('array'), PropertyType.array);
      expect(PropertyType.fromString('object'), PropertyType.object);
      expect(PropertyType.fromString('unknown'), PropertyType.string);
    });

    test('gets PropertyType value', () {
      expect(PropertyType.string.value, 'string');
      expect(PropertyType.integer.value, 'integer');
      expect(PropertyType.number.value, 'number');
      expect(PropertyType.boolean.value, 'boolean');
      expect(PropertyType.array.value, 'array');
      expect(PropertyType.object.value, 'object');
      expect(PropertyType.reference.value, 'reference');
    });
  });

  group('ParameterLocation', () {
    test('converts string to ParameterLocation', () {
      expect(ParameterLocation.fromString('query'), ParameterLocation.query);
      expect(ParameterLocation.fromString('path'), ParameterLocation.path);
      expect(ParameterLocation.fromString('header'), ParameterLocation.header);
      expect(ParameterLocation.fromString('cookie'), ParameterLocation.cookie);
      expect(ParameterLocation.fromString('unknown'), ParameterLocation.query);
    });
  });

  group('HttpMethod', () {
    test('converts string to HttpMethod', () {
      expect(HttpMethod.fromString('GET'), HttpMethod.get);
      expect(HttpMethod.fromString('POST'), HttpMethod.post);
      expect(HttpMethod.fromString('PUT'), HttpMethod.put);
      expect(HttpMethod.fromString('DELETE'), HttpMethod.delete);
      expect(HttpMethod.fromString('PATCH'), HttpMethod.patch);
      expect(HttpMethod.fromString('HEAD'), HttpMethod.head);
      expect(HttpMethod.fromString('OPTIONS'), HttpMethod.options);
    });

    test('handles case insensitive input', () {
      expect(HttpMethod.fromString('get'), HttpMethod.get);
      expect(HttpMethod.fromString('Post'), HttpMethod.post);
      expect(HttpMethod.fromString('put'), HttpMethod.put);
    });

    test('returns default for unknown method', () {
      expect(HttpMethod.fromString('UNKNOWN'), HttpMethod.get);
      expect(HttpMethod.fromString(''), HttpMethod.get);
    });

    test('gets HttpMethod value', () {
      expect(HttpMethod.get.value, 'GET');
      expect(HttpMethod.post.value, 'POST');
      expect(HttpMethod.put.value, 'PUT');
      expect(HttpMethod.delete.value, 'DELETE');
      expect(HttpMethod.patch.value, 'PATCH');
      expect(HttpMethod.head.value, 'HEAD');
      expect(HttpMethod.options.value, 'OPTIONS');
    });
  });

  group('SwaggerDocument', () {
    test('creates SwaggerDocument with required fields', () {
      final document = SwaggerDocument(
        title: 'Test API',
        version: '1.0.0',
        description: 'Test API description',
        host: 'api.example.com',
        basePath: '/api',
        schemes: ['https'],
        consumes: ['application/json'],
        produces: ['application/json'],
        paths: {},
        models: {},
        controllers: {},
      );

      expect(document.title, 'Test API');
      expect(document.version, '1.0.0');
      expect(document.description, 'Test API description');
      expect(document.host, 'api.example.com');
      expect(document.basePath, '/api');
      expect(document.schemes, ['https']);
      expect(document.consumes, ['application/json']);
      expect(document.produces, ['application/json']);
      expect(document.paths, isEmpty);
      expect(document.models, isEmpty);
      expect(document.controllers, isEmpty);
    });

    test('creates SwaggerDocument from JSON with all fields', () {
      final json = {
        'info': {
          'title': 'Test API',
          'version': '1.0.0',
          'description': 'Test API description',
        },
        'host': 'api.example.com',
        'basePath': '/api',
        'schemes': ['https', 'http'],
        'consumes': ['application/json', 'application/xml'],
        'produces': ['application/json', 'text/plain'],
      };

      final document = SwaggerDocument.fromJson(json);

      expect(document.title, 'Test API');
      expect(document.version, '1.0.0');
      expect(document.description, 'Test API description');
      expect(document.host, 'api.example.com');
      expect(document.basePath, '/api');
      expect(document.schemes, ['https', 'http']);
      expect(document.consumes, ['application/json', 'application/xml']);
      expect(document.produces, ['application/json', 'text/plain']);
    });

    test('creates SwaggerDocument from JSON with minimal fields', () {
      final json = <String, dynamic>{};

      final document = SwaggerDocument.fromJson(json);

      expect(document.title, 'API');
      expect(document.version, '1.0.0');
      expect(document.description, '');
      expect(document.host, '');
      expect(document.basePath, '');
      expect(document.schemes, ['https']);
      expect(document.consumes, ['application/json']);
      expect(document.produces, ['application/json']);
    });

    test('creates SwaggerDocument from JSON with null info', () {
      final json = {'info': null};

      final document = SwaggerDocument.fromJson(json);

      expect(document.title, 'API');
      expect(document.version, '1.0.0');
      expect(document.description, '');
    });
  });

  group('ApiController', () {
    test('creates ApiController with required fields', () {
      final controller = ApiController(
        name: 'UserController',
        description: 'User management controller',
        paths: [],
      );

      expect(controller.name, 'UserController');
      expect(controller.description, 'User management controller');
      expect(controller.paths, isEmpty);
    });

    test('creates ApiController with paths', () {
      final paths = [
        ApiPath(
          path: '/api/users',
          method: HttpMethod.get,
          summary: 'Get users',
          description: 'Retrieve all users',
          operationId: 'getUsers',
          tags: ['User'],
          parameters: [],
          responses: {},
          requestBody: null,
        ),
        ApiPath(
          path: '/api/users/{id}',
          method: HttpMethod.post,
          summary: 'Create user',
          description: 'Create a new user',
          operationId: 'createUser',
          tags: ['User'],
          parameters: [],
          responses: {},
          requestBody: null,
        ),
      ];

      final controller = ApiController(
        name: 'UserController',
        description: 'User management controller',
        paths: paths,
      );

      expect(controller.paths, hasLength(2));
      expect(controller.paths[0].path, '/api/users');
      expect(controller.paths[1].path, '/api/users/{id}');
    });

    test('creates ApiController from paths', () {
      final paths = [
        ApiPath(
          path: '/api/users',
          method: HttpMethod.get,
          summary: 'Get users',
          description: 'Retrieve all users',
          operationId: 'getUsers',
          tags: ['User'],
          parameters: [],
          responses: {},
          requestBody: null,
        ),
      ];

      final controller = ApiController.fromPaths('UserController', paths);

      expect(controller.name, 'UserController');
      expect(controller.description, 'UserController');
      expect(controller.paths, hasLength(1));
    });
  });

  group('ApiPath fromJson', () {
    test('creates ApiPath from JSON with all fields', () {
      final json = {
        'summary': 'Get users',
        'description': 'Retrieve all users',
        'operationId': 'getUsers',
        'tags': ['User'],
        'parameters': [
          <String, dynamic>{
            'name': 'id',
            'in': 'path',
            'required': true,
            'type': 'integer',
            'description': 'User ID',
          }
        ],
        'responses': <String, dynamic>{
          '200': <String, dynamic>{
            'description': 'Success',
            'schema': <String, dynamic>{'type': 'object'},
          }
        },
        'requestBody': <String, dynamic>{
          'description': 'User data',
          'required': true,
          'content': <String, dynamic>{
            'application/json': <String, dynamic>{
              'schema': <String, dynamic>{'type': 'object'},
            },
          },
        },
        'deprecated': true,
      };

      final path = ApiPath.fromJson('/api/users/{id}', 'PUT', json);

      expect(path.path, '/api/users/{id}');
      expect(path.method, HttpMethod.put);
      expect(path.summary, 'Get users');
      expect(path.description, 'Retrieve all users');
      expect(path.operationId, 'getUsers');
      expect(path.tags, ['User']);
      expect(path.parameters, hasLength(1));
      expect(path.responses, hasLength(1));
      expect(path.requestBody, isNotNull);
      expect(path.deprecated, true);
    });

    test('creates ApiPath from JSON with minimal fields', () {
      final json = <String, dynamic>{};

      final path = ApiPath.fromJson('/api/users', 'GET', json);

      expect(path.path, '/api/users');
      expect(path.method, HttpMethod.get);
      expect(path.summary, '');
      expect(path.description, '');
      expect(path.operationId, '');
      expect(path.tags, isEmpty);
      expect(path.parameters, isEmpty);
      expect(path.responses, isEmpty);
      expect(path.requestBody, isNull);
      expect(path.deprecated, false);
    });
  });

  group('ApiModel fromJson edge cases', () {
    test('creates ApiModel with nullable properties', () {
      final json = {
        'description': 'User model',
        'properties': {
          'id': {
            'type': 'integer',
            'description': 'User ID',
            'nullable': true,
          },
          'name': {
            'type': 'string',
            'description': 'User name',
            'nullable': false,
          },
        },
      };

      final model = ApiModel.fromJson('User', json);

      expect(model.properties['id']!.nullable, true);
      expect(model.properties['id']!.required, false);
      expect(model.properties['name']!.nullable, false);
      expect(model.properties['name']!.required, true);
      expect(model.required, ['name']);
    });

    test('creates ApiModel with explicit required fields', () {
      final json = {
        'description': 'User model',
        'properties': {
          'id': {
            'type': 'integer',
            'description': 'User ID',
            'nullable': true,
          },
          'name': {
            'type': 'string',
            'description': 'User name',
            'nullable': false,
          },
        },
        'required': ['id', 'name'],
      };

      final model = ApiModel.fromJson('User', json);

      expect(model.properties['id']!.required, true);
      expect(model.properties['name']!.required, true);
      expect(model.required, ['id', 'name']);
    });
  });

  group('ApiProperty complex types', () {
    test('creates ApiProperty with nested object', () {
      final json = {
        'type': 'object',
        'description': 'User address',
        'properties': {
          'street': {'type': 'string'},
          'city': {'type': 'string'},
        },
      };

      final property = ApiProperty.fromJson('address', json, []);

      expect(property.type, PropertyType.object);
      expect(property.description, 'User address');
      expect(property.required, false);
    });

    test('creates ApiProperty with array of primitives', () {
      final json = {
        'type': 'array',
        'description': 'User tags',
        'items': {
          'type': 'string',
        },
      };

      final property = ApiProperty.fromJson('tags', json, []);

      expect(property.type, PropertyType.array);
      expect(property.description, 'User tags');
      expect(property.items, isNotNull);
      expect(property.items!.name, 'string');
    });

    test('creates ApiProperty with array of objects', () {
      final json = {
        'type': 'array',
        'description': 'User list',
        'items': {
          'type': 'object',
          '\$ref': '#/components/schemas/User',
        },
      };

      final property = ApiProperty.fromJson('users', json, []);

      expect(property.type, PropertyType.array);
      expect(property.description, 'User list');
      expect(property.items, isNotNull);
      expect(property.items!.name, 'User');
    });

    test('creates ApiProperty with file type', () {
      final json = {
        'type': 'file',
        'description': 'User avatar',
        'format': 'binary',
      };

      final property = ApiProperty.fromJson('avatar', json, []);

      expect(property.type, PropertyType.file);
      expect(property.description, 'User avatar');
      expect(property.format, 'binary');
    });

    test('creates ApiProperty with date type', () {
      final json = {
        'type': 'string',
        'format': 'date',
        'description': 'User birth date',
      };

      final property = ApiProperty.fromJson('birthDate', json, []);

      expect(property.type, PropertyType.string);
      expect(property.format, 'date');
      expect(property.description, 'User birth date');
    });

    test('creates ApiProperty with date-time type', () {
      final json = {
        'type': 'string',
        'format': 'date-time',
        'description': 'User created at',
      };

      final property = ApiProperty.fromJson('createdAt', json, []);

      expect(property.type, PropertyType.string);
      expect(property.format, 'date-time');
      expect(property.description, 'User created at');
    });
  });

  group('Error handling and edge cases', () {
    test('ApiParameter fromJson handles missing fields gracefully', () {
      final json = <String, dynamic>{};

      final param = ApiParameter.fromJson(json);

      expect(param.name, '');
      expect(param.location, ParameterLocation.query);
      expect(param.required, false);
      expect(param.type, PropertyType.string);
      expect(param.description, '');
      expect(param.format, isNull);
      expect(param.example, isNull);
      expect(param.defaultValue, isNull);
    });

    test('ApiResponse fromJson handles missing fields gracefully', () {
      final json = <String, dynamic>{};

      final response = ApiResponse.fromJson('200', json);

      expect(response.code, '200');
      expect(response.description, '');
      expect(response.schema, isNull);
      expect(response.content, isNull);
    });

    test('ApiRequestBody fromJson handles missing fields gracefully', () {
      final json = <String, dynamic>{};

      final requestBody = ApiRequestBody.fromJson(json);

      expect(requestBody.description, '');
      expect(requestBody.required, false);
      expect(requestBody.content, isNull);
    });

    test('PropertyType fromString handles unknown types', () {
      expect(PropertyType.fromString('unknown'), PropertyType.string);
      expect(PropertyType.fromString(''), PropertyType.string);
      expect(PropertyType.fromString('CUSTOM_TYPE'), PropertyType.string);
    });

    test('ParameterLocation fromString handles unknown locations', () {
      expect(ParameterLocation.fromString('unknown'), ParameterLocation.query);
      expect(ParameterLocation.fromString(''), ParameterLocation.query);
      expect(ParameterLocation.fromString('CUSTOM_LOCATION'),
          ParameterLocation.query);
    });

    test('HttpMethod fromString handles unknown methods', () {
      expect(HttpMethod.fromString('unknown'), HttpMethod.get);
      expect(HttpMethod.fromString(''), HttpMethod.get);
      expect(HttpMethod.fromString('CUSTOM_METHOD'), HttpMethod.get);
    });
  });
}