int _parseInt(dynamic v, {required String field, required int fallback}) {
  if (v == null) {
    return fallback;
  }
  if (v is int) {
    return v;
  }
  if (v is String) {
    return int.tryParse(v) ?? (throw FormatException('$field invalid'));
  }
  throw FormatException('$field invalid type');
}

List<String> _parseStringList(dynamic v, {required String field}) {
  if (v == null) {
    return const [];
  }
  if (v is List && v.every((e) => e is String)) {
    return v.cast<String>();
  }
  throw FormatException('$field invalid type');
}

String _parseString(
  dynamic v, {
  required String field,
  required String fallback,
}) {
  if (v == null) {
    return fallback;
  }
  if (v is String) {
    return v;
  }
  throw FormatException('$field invalid type');
}

class MessageContextConfigModel {
  final String source;
  final String windowMode;
  final int windowCount;

  MessageContextConfigModel({
    required this.source,
    required this.windowMode,
    required this.windowCount,
  });

  factory MessageContextConfigModel.fromJson(Map<String, dynamic>? json) {
    if (json == null) {
      return MessageContextConfigModel(
        source: 'latest_chat',
        windowMode: 'day',
        windowCount: 2,
      );
    }
    return MessageContextConfigModel(
      source: _parseString(
        json['source'],
        field: 'source',
        fallback: 'latest_chat',
      ),
      windowMode: _parseString(
        json['window_mode'],
        field: 'window_mode',
        fallback: 'day',
      ),
      windowCount: _parseInt(
        json['window_count'],
        field: 'window_count',
        fallback: 2,
      ),
    );
  }

  Map<String, dynamic> toJson() => {
    'source': source,
    'window_mode': windowMode,
    'window_count': windowCount,
  };

  MessageContextConfigModel copyWith({
    String? source,
    String? windowMode,
    int? windowCount,
  }) {
    return MessageContextConfigModel(
      source: source ?? this.source,
      windowMode: windowMode ?? this.windowMode,
      windowCount: windowCount ?? this.windowCount,
    );
  }
}

class ScheduleRunAtModel {
  final int hour;
  final int minute;

  ScheduleRunAtModel({required this.hour, required this.minute});

  factory ScheduleRunAtModel.fromJson(Map<String, dynamic>? json) {
    if (json == null) {
      return ScheduleRunAtModel(hour: 8, minute: 0);
    }
    return ScheduleRunAtModel(
      hour: _parseInt(json['hour'], field: 'hour', fallback: 8),
      minute: _parseInt(json['minute'], field: 'minute', fallback: 0),
    );
  }

  Map<String, dynamic> toJson() => {'hour': hour, 'minute': minute};

  ScheduleRunAtModel copyWith({int? hour, int? minute}) {
    return ScheduleRunAtModel(
      hour: hour ?? this.hour,
      minute: minute ?? this.minute,
    );
  }
}

class ScheduleConfigModel {
  final String type;
  final ScheduleRunAtModel runAt;
  final List<int>? weekdays;

  ScheduleConfigModel({required this.type, required this.runAt, this.weekdays});

  factory ScheduleConfigModel.fromJson(Map<String, dynamic>? json) {
    if (json == null) {
      return ScheduleConfigModel(
        type: 'daily',
        runAt: ScheduleRunAtModel(hour: 8, minute: 0),
      );
    }
    final type = _parseString(json['type'], field: 'type', fallback: 'daily');
    final dynamic weekdaysRaw = json['weekdays'];
    List<int>? weekdays;
    if (weekdaysRaw is List) {
      weekdays = weekdaysRaw
          .map((item) => _parseInt(item, field: 'weekdays', fallback: 1))
          .toList();
    }
    return ScheduleConfigModel(
      type: type,
      runAt: ScheduleRunAtModel.fromJson(
        json['run_at'] as Map<String, dynamic>?,
      ),
      weekdays: type.toLowerCase() == 'weekly' ? weekdays ?? [1] : null,
    );
  }

  Map<String, dynamic> toJson() {
    final map = <String, dynamic>{'type': type, 'run_at': runAt.toJson()};
    if (weekdays != null) {
      map['weekdays'] = weekdays;
    }
    return map;
  }

  ScheduleConfigModel copyWith({
    String? type,
    ScheduleRunAtModel? runAt,
    List<int>? weekdays,
  }) {
    return ScheduleConfigModel(
      type: type ?? this.type,
      runAt: runAt ?? this.runAt,
      weekdays: weekdays ?? this.weekdays,
    );
  }
}

class AutomationJobConfigModel {
  final String inputTemplate;
  final List<String> enabledTools;
  final MessageContextConfigModel context;
  final ScheduleConfigModel schedule;

  AutomationJobConfigModel({
    required this.inputTemplate,
    required this.enabledTools,
    required this.context,
    required this.schedule,
  });

  factory AutomationJobConfigModel.fromJson(Map<String, dynamic>? json) {
    if (json == null) {
      return AutomationJobConfigModel(
        inputTemplate: '',
        enabledTools: const [],
        context: MessageContextConfigModel.fromJson(null),
        schedule: ScheduleConfigModel.fromJson(null),
      );
    }
    return AutomationJobConfigModel(
      inputTemplate: _parseString(
        json['input_template'],
        field: 'input_template',
        fallback: '',
      ),
      enabledTools: _parseStringList(
        json['enabled_tools'],
        field: 'enabled_tools',
      ),
      context: json['context'] != null
          ? MessageContextConfigModel.fromJson(
              json['context'] as Map<String, dynamic>?,
            )
          : MessageContextConfigModel.fromJson(null),
      schedule: json['schedule'] != null
          ? ScheduleConfigModel.fromJson(
              json['schedule'] as Map<String, dynamic>?,
            )
          : ScheduleConfigModel.fromJson(null),
    );
  }

  Map<String, dynamic> toJson() => {
    'input_template': inputTemplate,
    'enabled_tools': enabledTools,
    'context': context.toJson(),
    'schedule': schedule.toJson(),
  };

  AutomationJobConfigModel copyWith({
    String? inputTemplate,
    List<String>? enabledTools,
    MessageContextConfigModel? context,
    ScheduleConfigModel? schedule,
  }) {
    return AutomationJobConfigModel(
      inputTemplate: inputTemplate ?? this.inputTemplate,
      enabledTools: enabledTools ?? this.enabledTools,
      context: context ?? this.context,
      schedule: schedule ?? this.schedule,
    );
  }
}

class AutomationJobModel {
  final String id;
  final String ownerId;
  final String? bootstrapKey;
  final String title;
  final String timezone;
  final String status;
  final bool isSystem;
  final AutomationJobConfigModel config;
  final DateTime nextRunAt;
  final DateTime? lastRunAt;
  final DateTime createdAt;
  final DateTime updatedAt;

  AutomationJobModel({
    required this.id,
    required this.ownerId,
    this.bootstrapKey,
    required this.title,
    required this.timezone,
    required this.status,
    required this.isSystem,
    required this.config,
    required this.nextRunAt,
    this.lastRunAt,
    required this.createdAt,
    required this.updatedAt,
  });

  factory AutomationJobModel.fromJson(Map<String, dynamic> json) {
    return AutomationJobModel(
      id: _parseString(json['id'], field: 'id', fallback: ''),
      ownerId: _parseString(json['owner_id'], field: 'owner_id', fallback: ''),
      bootstrapKey: json['bootstrap_key'] == null
          ? null
          : _parseString(
              json['bootstrap_key'],
              field: 'bootstrap_key',
              fallback: '',
            ),
      title: _parseString(json['title'], field: 'title', fallback: ''),
      timezone: _parseString(
        json['timezone'],
        field: 'timezone',
        fallback: 'UTC',
      ),
      status: _parseString(json['status'], field: 'status', fallback: 'active'),
      isSystem: json['is_system'] == null
          ? false
          : (json['is_system'] is bool
                ? json['is_system'] as bool
                : throw FormatException('is_system invalid type')),
      config: json['config'] != null
          ? AutomationJobConfigModel.fromJson(
              json['config'] as Map<String, dynamic>?,
            )
          : AutomationJobConfigModel.fromJson(null),
      nextRunAt: json['next_run_at'] != null
          ? DateTime.parse(
              _parseString(
                json['next_run_at'],
                field: 'next_run_at',
                fallback: '',
              ),
            )
          : throw FormatException('next_run_at is required'),
      lastRunAt: json['last_run_at'] != null
          ? DateTime.parse(
              _parseString(
                json['last_run_at'],
                field: 'last_run_at',
                fallback: '',
              ),
            )
          : null,
      createdAt: json['created_at'] != null
          ? DateTime.parse(
              _parseString(
                json['created_at'],
                field: 'created_at',
                fallback: '',
              ),
            )
          : throw FormatException('created_at is required'),
      updatedAt: json['updated_at'] != null
          ? DateTime.parse(
              _parseString(
                json['updated_at'],
                field: 'updated_at',
                fallback: '',
              ),
            )
          : throw FormatException('updated_at is required'),
    );
  }

  Map<String, dynamic> toJson() => {
    'id': id,
    'owner_id': ownerId,
    'bootstrap_key': bootstrapKey,
    'title': title,
    'timezone': timezone,
    'status': status,
    'is_system': isSystem,
    'config': config.toJson(),
    'next_run_at': nextRunAt.toIso8601String(),
    'last_run_at': lastRunAt?.toIso8601String(),
    'created_at': createdAt.toIso8601String(),
    'updated_at': updatedAt.toIso8601String(),
  };

  AutomationJobModel copyWith({
    String? id,
    String? ownerId,
    String? bootstrapKey,
    String? title,
    String? timezone,
    String? status,
    bool? isSystem,
    AutomationJobConfigModel? config,
    DateTime? nextRunAt,
    DateTime? lastRunAt,
    DateTime? createdAt,
    DateTime? updatedAt,
  }) {
    return AutomationJobModel(
      id: id ?? this.id,
      ownerId: ownerId ?? this.ownerId,
      bootstrapKey: bootstrapKey ?? this.bootstrapKey,
      title: title ?? this.title,
      timezone: timezone ?? this.timezone,
      status: status ?? this.status,
      isSystem: isSystem ?? this.isSystem,
      config: config ?? this.config,
      nextRunAt: nextRunAt ?? this.nextRunAt,
      lastRunAt: lastRunAt ?? this.lastRunAt,
      createdAt: createdAt ?? this.createdAt,
      updatedAt: updatedAt ?? this.updatedAt,
    );
  }

  bool get isActive => status.toLowerCase() == 'active';

  bool get isDaily => config.schedule.type.toLowerCase() == 'daily';

  bool get isWeekly => config.schedule.type.toLowerCase() == 'weekly';
}

class AutomationJobListResponse {
  final List<AutomationJobModel> items;

  AutomationJobListResponse({required this.items});

  factory AutomationJobListResponse.fromJson(Map<String, dynamic>? json) {
    if (json == null) {
      return AutomationJobListResponse(items: const []);
    }
    final itemsJson = json['items'];
    if (itemsJson == null) {
      return AutomationJobListResponse(items: const []);
    }
    if (itemsJson is List) {
      return AutomationJobListResponse(
        items: itemsJson
            .map((e) => AutomationJobModel.fromJson(e as Map<String, dynamic>))
            .toList(),
      );
    }
    throw FormatException('items invalid type');
  }
}

class AutomationJobCreateRequest {
  final String title;
  final String timezone;
  final String status;
  final AutomationJobConfigModel config;

  AutomationJobCreateRequest({
    required this.title,
    required this.timezone,
    required this.status,
    required this.config,
  });

  Map<String, dynamic> toJson() => {
    'title': title,
    'timezone': timezone,
    'status': status,
    'config': config.toJson(),
  };
}

class AutomationJobConfigPatchModel {
  final String? inputTemplate;
  final List<String>? enabledTools;
  final MessageContextConfigModel? context;
  final ScheduleConfigModel? schedule;

  AutomationJobConfigPatchModel({
    this.inputTemplate,
    this.enabledTools,
    this.context,
    this.schedule,
  });

  Map<String, dynamic> toJson() {
    final map = <String, dynamic>{};
    if (inputTemplate != null) map['input_template'] = inputTemplate;
    if (enabledTools != null) map['enabled_tools'] = enabledTools;
    if (context != null) map['context'] = context!.toJson();
    if (schedule != null) map['schedule'] = schedule!.toJson();
    return map;
  }
}

class AutomationJobUpdateRequest {
  final String? title;
  final String? timezone;
  final String? status;
  final AutomationJobConfigPatchModel? config;

  AutomationJobUpdateRequest({
    this.title,
    this.timezone,
    this.status,
    this.config,
  });

  Map<String, dynamic> toJson() {
    final map = <String, dynamic>{};
    if (title != null) map['title'] = title;
    if (timezone != null) map['timezone'] = timezone;
    if (status != null) map['status'] = status;
    if (config != null) map['config'] = config!.toJson();
    return map;
  }
}