import 'dart:io';

import 'package:flutter/material.dart';
import 'package:rimworld_modman/logger.dart';
import 'package:rimworld_modman/mod.dart';
import 'package:rimworld_modman/mod_list.dart';
import 'package:rimworld_modman/mod_troubleshooter_widget.dart';

// Theme extension to store app-specific constants
class AppThemeExtension extends ThemeExtension<AppThemeExtension> {
  final double iconSizeSmall;
  final double iconSizeRegular;
  final double iconSizeLarge;
  final double textSizeSmall;
  final double textSizeRegular;
  final double textSizeLarge;
  final EdgeInsets paddingSmall;
  final EdgeInsets paddingRegular;
  final EdgeInsets paddingLarge;
  final Color enabledModColor;
  final Color enabledModBackgroundColor;
  final Color errorBackgroundColor;
  final Color warningColor;
  final Color errorColor;
  final Color baseGameColor;
  final Color expansionColor;
  final Color linkColor;
  final Color loadAfterColor;
  final Color loadBeforeColor;

  AppThemeExtension({
    required this.iconSizeSmall,
    required this.iconSizeRegular,
    required this.iconSizeLarge,
    required this.textSizeSmall,
    required this.textSizeRegular,
    required this.textSizeLarge,
    required this.paddingSmall,
    required this.paddingRegular,
    required this.paddingLarge,
    required this.enabledModColor,
    required this.enabledModBackgroundColor,
    required this.errorBackgroundColor,
    required this.warningColor,
    required this.errorColor,
    required this.baseGameColor,
    required this.expansionColor,
    required this.linkColor,
    required this.loadAfterColor,
    required this.loadBeforeColor,
  });

  static AppThemeExtension of(BuildContext context) {
    return Theme.of(context).extension<AppThemeExtension>()!;
  }

  @override
  ThemeExtension<AppThemeExtension> copyWith({
    double? iconSizeSmall,
    double? iconSizeRegular,
    double? iconSizeLarge,
    double? textSizeSmall,
    double? textSizeRegular,
    double? textSizeLarge,
    EdgeInsets? paddingSmall,
    EdgeInsets? paddingRegular,
    EdgeInsets? paddingLarge,
    Color? enabledModColor,
    Color? enabledModBackgroundColor,
    Color? errorBackgroundColor,
    Color? warningColor,
    Color? errorColor,
    Color? baseGameColor,
    Color? expansionColor,
    Color? linkColor,
    Color? loadAfterColor,
    Color? loadBeforeColor,
  }) {
    return AppThemeExtension(
      iconSizeSmall: iconSizeSmall ?? this.iconSizeSmall,
      iconSizeRegular: iconSizeRegular ?? this.iconSizeRegular,
      iconSizeLarge: iconSizeLarge ?? this.iconSizeLarge,
      textSizeSmall: textSizeSmall ?? this.textSizeSmall,
      textSizeRegular: textSizeRegular ?? this.textSizeRegular,
      textSizeLarge: textSizeLarge ?? this.textSizeLarge,
      paddingSmall: paddingSmall ?? this.paddingSmall,
      paddingRegular: paddingRegular ?? this.paddingRegular,
      paddingLarge: paddingLarge ?? this.paddingLarge,
      enabledModColor: enabledModColor ?? this.enabledModColor,
      enabledModBackgroundColor:
          enabledModBackgroundColor ?? this.enabledModBackgroundColor,
      errorBackgroundColor: errorBackgroundColor ?? this.errorBackgroundColor,
      warningColor: warningColor ?? this.warningColor,
      errorColor: errorColor ?? this.errorColor,
      baseGameColor: baseGameColor ?? this.baseGameColor,
      expansionColor: expansionColor ?? this.expansionColor,
      linkColor: linkColor ?? this.linkColor,
      loadAfterColor: loadAfterColor ?? this.loadAfterColor,
      loadBeforeColor: loadBeforeColor ?? this.loadBeforeColor,
    );
  }

  @override
  ThemeExtension<AppThemeExtension> lerp(
    covariant ThemeExtension<AppThemeExtension>? other,
    double t,
  ) {
    if (other is! AppThemeExtension) {
      return this;
    }
    return AppThemeExtension(
      iconSizeSmall: lerpDouble(iconSizeSmall, other.iconSizeSmall, t),
      iconSizeRegular: lerpDouble(iconSizeRegular, other.iconSizeRegular, t),
      iconSizeLarge: lerpDouble(iconSizeLarge, other.iconSizeLarge, t),
      textSizeSmall: lerpDouble(textSizeSmall, other.textSizeSmall, t),
      textSizeRegular: lerpDouble(textSizeRegular, other.textSizeRegular, t),
      textSizeLarge: lerpDouble(textSizeLarge, other.textSizeLarge, t),
      paddingSmall: EdgeInsets.lerp(paddingSmall, other.paddingSmall, t)!,
      paddingRegular: EdgeInsets.lerp(paddingRegular, other.paddingRegular, t)!,
      paddingLarge: EdgeInsets.lerp(paddingLarge, other.paddingLarge, t)!,
      enabledModColor: Color.lerp(enabledModColor, other.enabledModColor, t)!,
      enabledModBackgroundColor:
          Color.lerp(
            enabledModBackgroundColor,
            other.enabledModBackgroundColor,
            t,
          )!,
      errorBackgroundColor:
          Color.lerp(errorBackgroundColor, other.errorBackgroundColor, t)!,
      warningColor: Color.lerp(warningColor, other.warningColor, t)!,
      errorColor: Color.lerp(errorColor, other.errorColor, t)!,
      baseGameColor: Color.lerp(baseGameColor, other.baseGameColor, t)!,
      expansionColor: Color.lerp(expansionColor, other.expansionColor, t)!,
      linkColor: Color.lerp(linkColor, other.linkColor, t)!,
      loadAfterColor: Color.lerp(loadAfterColor, other.loadAfterColor, t)!,
      loadBeforeColor: Color.lerp(loadBeforeColor, other.loadBeforeColor, t)!,
    );
  }

  static AppThemeExtension light() {
    return AppThemeExtension(
      iconSizeSmall: 16,
      iconSizeRegular: 24,
      iconSizeLarge: 32,
      textSizeSmall: 10,
      textSizeRegular: 14,
      textSizeLarge: 18,
      paddingSmall: const EdgeInsets.all(4.0),
      paddingRegular: const EdgeInsets.all(8.0),
      paddingLarge: const EdgeInsets.all(16.0),
      enabledModColor: Colors.green,
      enabledModBackgroundColor: const Color.fromRGBO(0, 128, 0, 0.1),
      errorBackgroundColor: Color.fromRGBO(
        Colors.red.shade900.red,
        Colors.red.shade900.green,
        Colors.red.shade900.blue,
        0.3,
      ),
      warningColor: Colors.orange,
      errorColor: Colors.red,
      baseGameColor: Colors.blue,
      expansionColor: Colors.yellow,
      linkColor: Colors.orange,
      loadAfterColor: Colors.blue,
      loadBeforeColor: Colors.green,
    );
  }

  static AppThemeExtension dark() {
    return light(); // For now, we use the same values for both light and dark
  }
}

double lerpDouble(double a, double b, double t) {
  return a + (b - a) * t;
}

// Constants for file paths
final String root =
    Platform.isWindows
        ? r'C:/Users/Administrator/Seafile/Games-RimWorld'
        : '~/Library/Application Support/RimWorld';
final String modsRoot = Platform.isWindows ? '$root/294100' : '$root/Mods';
final String configRoot =
    Platform.isWindows
        ? '$root/AppData/RimWorld by Ludeon Studios/Config'
        : '$root/Config';
final String configPath = '$configRoot/ModsConfig.xml';
final String logsPath = '$root/ModManager';

late ModList modManager;

void main() {
  WidgetsFlutterBinding.ensureInitialized();

  // Get a reference to the logger (now auto-initializes)
  final logger = Logger.instance;
  logger.info('RimWorld Mod Manager starting...');

  // Initialize the mod manager
  modManager = ModList(modsPath: modsRoot, configPath: configPath);

  // Start the app
  runApp(const RimWorldModManager());
}

class RimWorldModManager extends StatelessWidget {
  const RimWorldModManager({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'RimWorld Mod Manager',
      theme: ThemeData.dark().copyWith(
        primaryColor: const Color(0xFF3D4A59),
        colorScheme: ColorScheme.fromSeed(
          seedColor: const Color(0xFF3D4A59),
          brightness: Brightness.dark,
        ),
        scaffoldBackgroundColor: const Color(0xFF1E262F),
        cardColor: const Color(0xFF2A3440),
        appBarTheme: const AppBarTheme(
          backgroundColor: Color(0xFF2A3440),
          foregroundColor: Colors.white,
        ),
        extensions: [AppThemeExtension.dark()],
      ),
      home: const ModManagerHomePage(),
    );
  }
}

class ModManagerHomePage extends StatefulWidget {
  const ModManagerHomePage({super.key});

  @override
  State<ModManagerHomePage> createState() => _ModManagerHomePageState();
}

class _ModManagerHomePageState extends State<ModManagerHomePage> {
  int _selectedIndex = 0;

  final List<Widget> _pages = [
    const ModManagerPage(),
    const TroubleshootingPage(),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('RimWorld Mod Manager')),
      body: _pages[_selectedIndex],
      bottomNavigationBar: BottomNavigationBar(
        currentIndex: _selectedIndex,
        onTap: (index) {
          setState(() {
            _selectedIndex = index;
          });
        },
        items: const [
          BottomNavigationBarItem(icon: Icon(Icons.extension), label: 'Mods'),
          BottomNavigationBarItem(
            icon: Icon(Icons.build),
            label: 'Troubleshoot',
          ),
        ],
      ),
    );
  }
}

// Combined page for mod management with two-panel layout
class ModManagerPage extends StatefulWidget {
  const ModManagerPage({super.key});

  @override
  State<ModManagerPage> createState() => _ModManagerPageState();
}

class _ModManagerPageState extends State<ModManagerPage> {
  // For all available mods (left panel)
  List<Mod> _availableMods = [];

  // For active mods (right panel)
  List<Mod> _activeMods = [];

  bool _isLoading = false;
  String _statusMessage = '';
  bool _skipFileCount = false;
  bool _hasCycles = false;
  List<String>? _cycleInfo;
  List<List<String>> _incompatibleMods = [];
  List<String>? _loadOrderErrors;

  final TextEditingController _searchController = TextEditingController();
  String _searchQuery = '';

  @override
  void initState() {
    super.initState();
    // Check if mods are already loaded
    if (modManager.mods.isNotEmpty) {
      _loadModsFromGlobalState();
    }

    _searchController.addListener(() {
      setState(() {
        _searchQuery = _searchController.text.toLowerCase();
      });
    });
  }

  @override
  void dispose() {
    _searchController.dispose();
    super.dispose();
  }

  void _loadModsFromGlobalState() {
    setState(() {
      // Get all mods for the left panel (sorted alphabetically)
      _availableMods = modManager.mods.values.toList();
      _availableMods.sort((a, b) => a.name.compareTo(b.name));

      // Get active mods for the right panel (in load order)
      _activeMods = modManager.mods.values.where((m) => m.enabled).toList();
      _isLoading = false;
      _statusMessage = 'Loaded ${_availableMods.length} mods';
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body:
          _isLoading && _availableMods.isEmpty
              ? _buildLoadingView()
              : _availableMods.isEmpty
              ? _buildEmptyState()
              : _buildSplitView(),
    );
  }

  Widget _buildLoadingView() {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          const CircularProgressIndicator(),
          const SizedBox(height: 16),
          Text(
            _statusMessage,
            style: Theme.of(context).textTheme.bodyMedium,
            textAlign: TextAlign.center,
          ),
        ],
      ),
    );
  }

  Widget _buildEmptyState() {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          const Icon(Icons.extension, size: 64),
          const SizedBox(height: 16),
          Text(
            'Mod Manager',
            style: Theme.of(context).textTheme.headlineMedium,
          ),
          const SizedBox(height: 16),
          Text(
            'Ready to scan for RimWorld mods.',
            style: Theme.of(context).textTheme.bodyLarge,
          ),
          const SizedBox(height: 12),
          Row(
            mainAxisSize: MainAxisSize.min,
            children: [
              Checkbox(
                value: _skipFileCount,
                onChanged: (value) {
                  setState(() {
                    _skipFileCount = value ?? true;
                  });
                },
              ),
              const Text('Skip file counting (faster loading)'),
            ],
          ),
          const SizedBox(height: 24),
          ElevatedButton(
            onPressed: _startLoadingMods,
            child: const Text('Scan for Mods'),
          ),
        ],
      ),
    );
  }

  Widget _buildSplitView() {
    // Filter both available and active mods based on search query
    final filteredAvailableMods =
        _searchQuery.isEmpty
            ? _availableMods
            : _availableMods
                .where(
                  (mod) =>
                      mod.name.toLowerCase().contains(_searchQuery) ||
                      mod.id.toLowerCase().contains(_searchQuery),
                )
                .toList();

    final filteredActiveMods =
        _searchQuery.isEmpty
            ? _activeMods
            : _activeMods
                .where(
                  (mod) =>
                      mod.name.toLowerCase().contains(_searchQuery) ||
                      mod.id.toLowerCase().contains(_searchQuery),
                )
                .toList();

    return Column(
      children: [
        Padding(
          padding: AppThemeExtension.of(context).paddingRegular,
          child: Row(
            children: [
              // Search field
              Expanded(
                child: TextField(
                  controller: _searchController,
                  decoration: InputDecoration(
                    hintText: 'Search mods by name or ID...',
                    prefixIcon: const Icon(Icons.search),
                    border: OutlineInputBorder(
                      borderRadius: BorderRadius.circular(8.0),
                    ),
                    suffixIcon:
                        _searchQuery.isNotEmpty
                            ? IconButton(
                              icon: const Icon(Icons.clear),
                              onPressed: () {
                                _searchController.clear();
                              },
                            )
                            : null,
                  ),
                ),
              ),
              const SizedBox(width: 8),
              // Reload button
              IconButton(
                icon: const Icon(Icons.refresh),
                tooltip: 'Reload mods',
                onPressed: _startLoadingMods,
              ),
              const SizedBox(width: 8),
              // Load Dependencies button
              Tooltip(
                message:
                    'Automatically load missing dependencies for active mods',
                child: ElevatedButton.icon(
                  icon: const Icon(Icons.download),
                  label: const Text('Load Deps'),
                  onPressed: _loadRequiredDependencies,
                ),
              ),
              const SizedBox(width: 8),
              // Auto-sort button
              ElevatedButton.icon(
                icon: const Icon(Icons.sort),
                label: const Text('Auto-Sort'),
                onPressed: _sortActiveMods,
              ),
              const SizedBox(width: 8),
              // Save button
              ElevatedButton.icon(
                icon: const Icon(Icons.save),
                label: const Text('Save'),
                onPressed: _saveModOrder,
              ),
            ],
          ),
        ),

        // Status message
        if (!_isLoading && _statusMessage.isNotEmpty)
          Padding(
            padding: const EdgeInsets.symmetric(horizontal: 8.0, vertical: 4.0),
            child: Text(
              _statusMessage,
              style: TextStyle(
                color:
                    _hasCycles || _incompatibleMods.isNotEmpty
                        ? Colors.orange
                        : Colors.green,
              ),
            ),
          ),

        // Error display section
        if (_hasCycles ||
            _incompatibleMods.isNotEmpty ||
            (_loadOrderErrors?.isNotEmpty ?? false))
          Container(
            margin: EdgeInsets.symmetric(
              horizontal:
                  AppThemeExtension.of(context).paddingRegular.horizontal,
              vertical: AppThemeExtension.of(context).paddingSmall.vertical,
            ),
            padding: AppThemeExtension.of(context).paddingRegular,
            decoration: BoxDecoration(
              color: AppThemeExtension.of(context).errorBackgroundColor,
              borderRadius: BorderRadius.circular(4.0),
              border: Border.all(color: Colors.red.shade800),
            ),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                // Cycle warnings
                if (_hasCycles && _cycleInfo != null)
                  Padding(
                    padding: const EdgeInsets.only(bottom: 4.0),
                    child: Row(
                      children: [
                        Icon(
                          Icons.loop,
                          color: AppThemeExtension.of(context).warningColor,
                          size: AppThemeExtension.of(context).iconSizeSmall,
                        ),
                        const SizedBox(width: 4),
                        Expanded(
                          child: Text(
                            'Dependency cycle detected: ${_cycleInfo!.join(" -> ")}',
                            style: TextStyle(
                              color: AppThemeExtension.of(context).warningColor,
                            ),
                          ),
                        ),
                      ],
                    ),
                  ),

                // Incompatible mod warnings
                if (_incompatibleMods.isNotEmpty)
                  Padding(
                    padding: const EdgeInsets.only(bottom: 4.0),
                    child: Row(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Icon(
                          Icons.warning,
                          color: AppThemeExtension.of(context).warningColor,
                          size: AppThemeExtension.of(context).iconSizeSmall,
                        ),
                        const SizedBox(width: 4),
                        Expanded(
                          child: Column(
                            crossAxisAlignment: CrossAxisAlignment.start,
                            children: [
                              Text(
                                '${_incompatibleMods.length} incompatible mod pairs:',
                                style: TextStyle(
                                  color:
                                      AppThemeExtension.of(
                                        context,
                                      ).warningColor,
                                ),
                              ),
                              if (_incompatibleMods.length <= 3)
                                ...List.generate(_incompatibleMods.length, (
                                  index,
                                ) {
                                  final pair = _incompatibleMods[index];
                                  final mod1 =
                                      modManager.mods[pair[0]]?.name ?? pair[0];
                                  final mod2 =
                                      modManager.mods[pair[1]]?.name ?? pair[1];
                                  return Padding(
                                    padding: const EdgeInsets.only(
                                      left: 12.0,
                                      top: 2.0,
                                    ),
                                    child: Text(
                                      '• $mod1 ↔ $mod2',
                                      style: TextStyle(
                                        color: Colors.orange.shade300,
                                        fontSize:
                                            AppThemeExtension.of(
                                              context,
                                            ).textSizeSmall,
                                      ),
                                    ),
                                  );
                                }),
                            ],
                          ),
                        ),
                      ],
                    ),
                  ),

                // Other errors (missing dependencies, etc.)
                if (_loadOrderErrors?.isNotEmpty ?? false)
                  Row(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      Icon(
                        Icons.error_outline,
                        color: AppThemeExtension.of(context).errorColor,
                        size: AppThemeExtension.of(context).iconSizeSmall,
                      ),
                      const SizedBox(width: 4),
                      Expanded(
                        child: Column(
                          crossAxisAlignment: CrossAxisAlignment.start,
                          children: [
                            Text(
                              'Dependency errors:',
                              style: TextStyle(
                                color: AppThemeExtension.of(context).errorColor,
                              ),
                            ),
                            ...List.generate(
                              _loadOrderErrors!.length > 5
                                  ? 5
                                  : _loadOrderErrors!.length,
                              (index) => Padding(
                                padding: const EdgeInsets.only(
                                  left: 12.0,
                                  top: 2.0,
                                ),
                                child: Text(
                                  '• ${_loadOrderErrors![index]}',
                                  style: TextStyle(
                                    color: Colors.red.shade300,
                                    fontSize:
                                        AppThemeExtension.of(
                                          context,
                                        ).textSizeRegular,
                                  ),
                                ),
                              ),
                            ),
                            if (_loadOrderErrors!.length > 5)
                              Padding(
                                padding: const EdgeInsets.only(
                                  left: 12.0,
                                  top: 4.0,
                                ),
                                child: Text(
                                  '(${_loadOrderErrors!.length - 5} more errors...)',
                                  style: TextStyle(
                                    color: Colors.red.shade300,
                                    fontSize:
                                        AppThemeExtension.of(
                                          context,
                                        ).textSizeSmall,
                                    fontStyle: FontStyle.italic,
                                  ),
                                ),
                              ),
                          ],
                        ),
                      ),
                    ],
                  ),
              ],
            ),
          ),

        // Main split view
        Expanded(
          child: Row(
            children: [
              // LEFT PANEL - All available mods (alphabetical)
              Expanded(
                child: Card(
                  margin: AppThemeExtension.of(context).paddingRegular,
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.stretch,
                    children: [
                      Container(
                        color: Theme.of(context).primaryColor,
                        padding: const EdgeInsets.all(8.0),
                        child: Text(
                          'Available Mods (${filteredAvailableMods.length}${_searchQuery.isNotEmpty ? '/${_availableMods.length}' : ''})',
                          style: const TextStyle(fontWeight: FontWeight.bold),
                          textAlign: TextAlign.center,
                        ),
                      ),
                      if (_searchQuery.isNotEmpty)
                        Padding(
                          padding: AppThemeExtension.of(context).paddingSmall,
                          child: Text(
                            'Searching: "$_searchQuery"',
                            style: TextStyle(
                              fontSize:
                                  AppThemeExtension.of(context).textSizeSmall,
                              fontStyle: FontStyle.italic,
                              color: Colors.grey.shade400,
                            ),
                            textAlign: TextAlign.center,
                          ),
                        ),
                      Expanded(
                        child: ListView.builder(
                          itemCount: filteredAvailableMods.length,
                          itemBuilder: (context, index) {
                            final mod = filteredAvailableMods[index];
                            final isActive = mod.enabled;

                            return GestureDetector(
                              onDoubleTap: () => _toggleModActive(mod),
                              child: ListTile(
                                title: Text(
                                  mod.name,
                                  style: TextStyle(
                                    color:
                                        isActive
                                            ? AppThemeExtension.of(
                                              context,
                                            ).enabledModColor
                                            : Colors.white,
                                  ),
                                ),
                                subtitle: Text(
                                  'ID: ${mod.id}\nSize: ${mod.size} files',
                                  style: Theme.of(context).textTheme.bodySmall,
                                ),
                                tileColor:
                                    isActive
                                        ? AppThemeExtension.of(
                                          context,
                                        ).enabledModBackgroundColor
                                        : null,
                                trailing: Row(
                                  mainAxisSize: MainAxisSize.min,
                                  children: [
                                    if (mod.isBaseGame)
                                      Tooltip(
                                        message: 'Base Game',
                                        child: Icon(
                                          Icons.home,
                                          color:
                                              AppThemeExtension.of(
                                                context,
                                              ).baseGameColor,
                                          size:
                                              AppThemeExtension.of(
                                                context,
                                              ).iconSizeRegular,
                                        ),
                                      ),
                                    if (mod.isExpansion)
                                      Tooltip(
                                        message: 'Expansion',
                                        child: Icon(
                                          Icons.star,
                                          color:
                                              AppThemeExtension.of(
                                                context,
                                              ).expansionColor,
                                          size:
                                              AppThemeExtension.of(
                                                context,
                                              ).iconSizeRegular,
                                        ),
                                      ),
                                    const SizedBox(width: 4),
                                    if (mod.dependencies.isNotEmpty)
                                      Tooltip(
                                        message:
                                            'Dependencies:\n${mod.dependencies.join('\n')}',
                                        child: Icon(
                                          Icons.link,
                                          color:
                                              AppThemeExtension.of(
                                                context,
                                              ).linkColor,
                                          size:
                                              AppThemeExtension.of(
                                                context,
                                              ).iconSizeRegular,
                                        ),
                                      ),
                                    if (mod.loadAfter.isNotEmpty)
                                      Tooltip(
                                        message:
                                            'Loads after:\n${mod.loadAfter.join('\n')}',
                                        child: Icon(
                                          Icons.arrow_downward,
                                          color:
                                              AppThemeExtension.of(
                                                context,
                                              ).loadAfterColor,
                                          size:
                                              AppThemeExtension.of(
                                                context,
                                              ).iconSizeRegular,
                                        ),
                                      ),
                                    if (mod.loadBefore.isNotEmpty)
                                      Tooltip(
                                        message:
                                            'Loads before:\n${mod.loadBefore.join('\n')}',
                                        child: Icon(
                                          Icons.arrow_upward,
                                          color:
                                              AppThemeExtension.of(
                                                context,
                                              ).loadBeforeColor,
                                          size:
                                              AppThemeExtension.of(
                                                context,
                                              ).iconSizeRegular,
                                        ),
                                      ),
                                  ],
                                ),
                                onTap: () {
                                  // Show mod details in future
                                },
                              ),
                            );
                          },
                        ),
                      ),
                    ],
                  ),
                ),
              ),

              // RIGHT PANEL - Active mods (load order)
              Expanded(
                child: Card(
                  margin: AppThemeExtension.of(context).paddingRegular,
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.stretch,
                    children: [
                      Container(
                        color: Theme.of(context).primaryColor,
                        padding: const EdgeInsets.all(8.0),
                        child: Text(
                          'Active Mods (${filteredActiveMods.length}${_searchQuery.isNotEmpty ? '/${_activeMods.length}' : ''})',
                          style: const TextStyle(fontWeight: FontWeight.bold),
                          textAlign: TextAlign.center,
                        ),
                      ),
                      Padding(
                        padding: AppThemeExtension.of(context).paddingRegular,
                        child: Text(
                          _searchQuery.isNotEmpty
                              ? 'Searching: "$_searchQuery"'
                              : 'Larger mods are prioritized during auto-sorting.',
                          style: TextStyle(
                            fontSize:
                                AppThemeExtension.of(context).textSizeSmall,
                            color: Colors.grey.shade400,
                            fontStyle: FontStyle.italic,
                          ),
                          textAlign: TextAlign.center,
                        ),
                      ),
                      Expanded(
                        child: ListView.builder(
                          itemCount: filteredActiveMods.length,
                          itemBuilder: (context, index) {
                            final mod = filteredActiveMods[index];
                            // Find the actual position in the complete active mods list (for correct load order)
                            final actualLoadOrderPosition =
                                _activeMods.indexWhere((m) => m.id == mod.id) +
                                1;

                            return GestureDetector(
                              onDoubleTap: () {
                                // Don't allow deactivating base game or expansions
                                if (!mod.isBaseGame && !mod.isExpansion) {
                                  _toggleModActive(mod);
                                } else {
                                  ScaffoldMessenger.of(context).showSnackBar(
                                    const SnackBar(
                                      content: Text(
                                        'Core game and expansions cannot be deactivated',
                                      ),
                                      backgroundColor: Colors.orange,
                                    ),
                                  );
                                }
                              },
                              child: Card(
                                margin:
                                    AppThemeExtension.of(
                                      context,
                                    ).paddingRegular,
                                child: ListTile(
                                  leading: SizedBox(
                                    width: 50,
                                    child: Column(
                                      mainAxisSize: MainAxisSize.min,
                                      mainAxisAlignment:
                                          MainAxisAlignment.center,
                                      children: [
                                        SizedBox(
                                          height: 24,
                                          child: Container(
                                            padding: const EdgeInsets.symmetric(
                                              horizontal: 4,
                                            ),
                                            decoration: BoxDecoration(
                                              color:
                                                  _searchQuery.isNotEmpty
                                                      ? const Color.fromRGBO(
                                                        0,
                                                        0,
                                                        255,
                                                        0.2,
                                                      )
                                                      : null,
                                              borderRadius:
                                                  BorderRadius.circular(4),
                                            ),
                                            child: Tooltip(
                                              message:
                                                  'Load position: $actualLoadOrderPosition of ${_activeMods.length}${_searchQuery.isNotEmpty ? " (preserved when filtering)" : ""}',
                                              child: Text(
                                                '$actualLoadOrderPosition',
                                                style: TextStyle(
                                                  fontWeight: FontWeight.bold,
                                                  fontSize:
                                                      AppThemeExtension.of(
                                                        context,
                                                      ).textSizeSmall,
                                                  color:
                                                      _searchQuery.isNotEmpty
                                                          ? Colors.blue.shade300
                                                          : null,
                                                ),
                                              ),
                                            ),
                                          ),
                                        ),
                                        SizedBox(
                                          height: 24,
                                          child: Center(
                                            child:
                                                mod.size > 0
                                                    ? Tooltip(
                                                      message:
                                                          'This mod contains ${mod.size} files.',
                                                      child: Text(
                                                        '${mod.size}',
                                                        style: TextStyle(
                                                          fontSize:
                                                              AppThemeExtension.of(
                                                                context,
                                                              ).textSizeSmall,
                                                          color: Colors.grey,
                                                        ),
                                                      ),
                                                    )
                                                    : const SizedBox(),
                                          ),
                                        ),
                                      ],
                                    ),
                                  ),
                                  title: Text(mod.name),
                                  subtitle: Text(
                                    mod.id,
                                    style: TextStyle(
                                      fontSize:
                                          AppThemeExtension.of(
                                            context,
                                          ).textSizeSmall,
                                    ),
                                  ),
                                  trailing: Row(
                                    mainAxisSize: MainAxisSize.min,
                                    children: [
                                      if (mod.isBaseGame)
                                        Tooltip(
                                          message: 'Base Game',
                                          child: Icon(
                                            Icons.home,
                                            color:
                                                AppThemeExtension.of(
                                                  context,
                                                ).baseGameColor,
                                            size:
                                                AppThemeExtension.of(
                                                  context,
                                                ).iconSizeRegular,
                                          ),
                                        ),
                                      if (mod.isExpansion)
                                        Tooltip(
                                          message: 'Expansion',
                                          child: Icon(
                                            Icons.star,
                                            color:
                                                AppThemeExtension.of(
                                                  context,
                                                ).expansionColor,
                                            size:
                                                AppThemeExtension.of(
                                                  context,
                                                ).iconSizeRegular,
                                          ),
                                        ),
                                      if (mod.dependencies.isNotEmpty)
                                        Tooltip(
                                          message:
                                              'Dependencies:\n${mod.dependencies.join('\n')}',
                                          child: Icon(
                                            Icons.link,
                                            color:
                                                AppThemeExtension.of(
                                                  context,
                                                ).linkColor,
                                            size:
                                                AppThemeExtension.of(
                                                  context,
                                                ).iconSizeRegular,
                                          ),
                                        ),
                                      const SizedBox(width: 4),
                                      if (mod.loadAfter.isNotEmpty)
                                        Tooltip(
                                          message:
                                              'Loads after other mods:\n${mod.loadAfter.join('\n')}',
                                          child: Icon(
                                            Icons.arrow_downward,
                                            color:
                                                AppThemeExtension.of(
                                                  context,
                                                ).loadAfterColor,
                                            size:
                                                AppThemeExtension.of(
                                                  context,
                                                ).iconSizeRegular,
                                          ),
                                        ),
                                      const SizedBox(width: 4),
                                      if (mod.loadBefore.isNotEmpty)
                                        Tooltip(
                                          message:
                                              'Loads before other mods:\n${mod.loadBefore.join('\n')}',
                                          child: Icon(
                                            Icons.arrow_upward,
                                            color:
                                                AppThemeExtension.of(
                                                  context,
                                                ).loadBeforeColor,
                                            size:
                                                AppThemeExtension.of(
                                                  context,
                                                ).iconSizeRegular,
                                          ),
                                        ),
                                    ],
                                  ),
                                  onTap: () {
                                    // Show mod details in future
                                  },
                                ),
                              ),
                            );
                          },
                        ),
                      ),
                    ],
                  ),
                ),
              ),
            ],
          ),
        ),
      ],
    );
  }

  void _startLoadingMods() {
    setState(() {
      _availableMods.clear();
      _activeMods.clear();
      _isLoading = true;
      _statusMessage = 'Scanning for mods...';
      _hasCycles = false;
      _cycleInfo = null;
      _incompatibleMods = [];
    });

    // Create an async function to load mods
    Future<void> loadMods() async {
      try {
        // First load available mods
        await for (final mod in modManager.loadAvailable()) {
          // Update UI for each mod loaded
          if (mounted) {
            setState(() {
              _statusMessage = 'Loaded mod: ${mod.name}';
            });
          }
        }

        // Then load active mods from config
        await for (final mod in modManager.loadActive()) {
          // Update UI as active mods are loaded
          if (mounted) {
            setState(() {
              _statusMessage = 'Loading active mod: ${mod.name}';
            });
          }
        }

        // Update the UI with all loaded mods
        if (mounted) {
          _loadModsFromGlobalState();
          setState(() {
            _statusMessage =
                'Loaded ${_availableMods.length} mods, ${_activeMods.length} active';
          });
        }
      } catch (error) {
        if (mounted) {
          setState(() {
            _isLoading = false;
            _statusMessage = 'Error loading mods: $error';
          });
        }
      }
    }

    // Start the loading process
    loadMods();
  }

  void _toggleModActive(Mod mod) {
    // Cannot deactivate base game or expansions
    if ((mod.isBaseGame || mod.isExpansion) && mod.enabled) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(
          content: Text('Core game and expansions cannot be deactivated'),
          backgroundColor: Colors.orange,
        ),
      );
      return;
    }

    // Get the current state before toggling
    final bool wasEnabled = mod.enabled;

    // Toggle the mod in the global mod manager
    modManager.setEnabled(mod.id, !wasEnabled);
    Logger.instance.info(
      'Toggled mod ${mod.name} (${mod.id}) from ${wasEnabled ? 'enabled' : 'disabled'} to ${!wasEnabled ? 'enabled' : 'disabled'}',
    );

    // Update the UI
    setState(() {
      // Update in the available mods list
      final index = _availableMods.indexWhere((m) => m.id == mod.id);
      if (index >= 0) {
        _availableMods[index] = modManager.mods[mod.id]!;
      }

      // Update the active mods list
      _activeMods = modManager.mods.values.where((m) => m.enabled).toList();

      _statusMessage =
          'Mod "${mod.name}" ${!wasEnabled ? 'activated' : 'deactivated'}';
    });
  }

  void _sortActiveMods() async {
    if (_activeMods.isEmpty) {
      setState(() {
        _statusMessage = 'No active mods to sort';
      });
      return;
    }

    setState(() {
      _isLoading = true;
      _statusMessage = 'Sorting mods based on dependencies...';
      _hasCycles = false;
      _cycleInfo = null;
      _incompatibleMods = [];
      _loadOrderErrors = null;
    });

    // Use a Future.delayed to allow the UI to update
    await Future.delayed(Duration.zero);

    try {
      final logger = Logger.instance;
      logger.info('Starting auto-sort of ${_activeMods.length} active mods');

      // Generate a load order for active mods
      final loadOrder = modManager.generateLoadOrder();

      // Store all errors
      if (loadOrder.hasErrors) {
        setState(() {
          _loadOrderErrors = List<String>.from(loadOrder.errors);
        });

        logger.warning(
          'Found ${loadOrder.errors.length} errors during sorting',
        );
        for (final error in loadOrder.errors) {
          logger.warning('  - $error');
        }

        setState(() {
          _hasCycles = loadOrder.errors.any(
            (e) => e.contains('Cyclic dependency'),
          );
          if (_hasCycles) {
            // Extract cycle info from error message
            final cycleError = loadOrder.errors.firstWhere(
              (e) => e.contains('Cyclic dependency'),
              orElse: () => '',
            );
            logger.warning('Detected dependency cycle: $cycleError');

            if (cycleError.isNotEmpty) {
              // Extract cycle path from error message
              final startIndex = cycleError.indexOf(':');
              if (startIndex != -1) {
                final pathStr = cycleError.substring(startIndex + 1).trim();
                _cycleInfo = pathStr.split(' -> ');
                logger.info(
                  'Extracted cycle path: ${_cycleInfo!.join(" -> ")}',
                );
              }
            }
          }
        });
      } else {
        _loadOrderErrors = null;
      }

      // Check for incompatibilities
      _incompatibleMods = modManager.checkIncompatibilities(
        modManager.activeMods.keys.toList(),
      );

      if (_incompatibleMods.isNotEmpty) {
        logger.warning(
          'Found ${_incompatibleMods.length} incompatible mod pairs:',
        );
        for (final pair in _incompatibleMods) {
          final mod1 = modManager.mods[pair[0]]?.name ?? pair[0];
          final mod2 = modManager.mods[pair[1]]?.name ?? pair[1];
          logger.warning('  - $mod1 is incompatible with $mod2');
        }
      }

      // Get sorted mods from the load order
      final List<Mod> sortedMods = [];
      for (final modId in loadOrder.loadOrder) {
        if (modManager.mods.containsKey(modId)) {
          sortedMods.add(modManager.mods[modId]!);
        }
      }

      logger.info(
        'Sorting complete. Arranged ${sortedMods.length} mods in load order',
      );
      if (sortedMods.isNotEmpty) {
        logger.info(
          'First 5 mods in order: ${sortedMods.take(5).map((m) => m.name).join(', ')}',
        );
        if (sortedMods.length > 5) {
          logger.info('... (${sortedMods.length - 5} more) ...');
          logger.info(
            'Last 3 mods in order: ${sortedMods.reversed.take(3).map((m) => m.name).toList().reversed.join(', ')}',
          );
        }
      }

      setState(() {
        _activeMods = sortedMods;
        _isLoading = false;
        _statusMessage = 'Sorting complete! ${sortedMods.length} mods sorted.';
        if (_hasCycles) {
          _statusMessage += ' Warning: Dependency cycles were found and fixed.';
        }
        if (_incompatibleMods.isNotEmpty) {
          _statusMessage +=
              ' Warning: ${_incompatibleMods.length} incompatible mod pairs found.';
        }
      });
    } catch (e) {
      Logger.instance.error('Error during auto-sort: $e');
      setState(() {
        _isLoading = false;
        _statusMessage = 'Error sorting mods: $e';
      });
    }
  }

  void _saveModOrder() async {
    if (_activeMods.isEmpty) {
      setState(() {
        _statusMessage = 'No active mods to save';
      });
      return;
    }

    setState(() {
      _isLoading = true;
      _statusMessage = 'Saving mod load order...';
    });

    try {
      final logger = Logger.instance;
      logger.info(
        'Saving mod load order for ${_activeMods.length} active mods to $configPath',
      );

      modManager.saveToConfig(LoadOrder(_activeMods));

      setState(() {
        _isLoading = false;
        _statusMessage = 'Mod load order saved successfully!';
      });

      // Show success message
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text(
              'Mod order saved to config. ${_activeMods.length} mods enabled.',
            ),
            backgroundColor: Colors.green,
          ),
        );
      }
    } catch (e) {
      final logger = Logger.instance;
      logger.error('Error saving mod load order: $e');

      setState(() {
        _isLoading = false;
        _statusMessage = 'Error saving mod load order: $e';
      });

      // Show error message
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('Error saving mod order: $e'),
            backgroundColor: Colors.red,
          ),
        );
      }
    }
  }

  // Load all required dependencies for active mods
  void _loadRequiredDependencies() async {
    if (_activeMods.isEmpty) {
      setState(() {
        _statusMessage = 'No active mods to load dependencies for';
      });
      return;
    }

    setState(() {
      _isLoading = true;
      _statusMessage = 'Loading required dependencies...';
      _hasCycles = false;
      _cycleInfo = null;
      _incompatibleMods = [];
      _loadOrderErrors = null;
    });

    // Use a Future.delayed to allow the UI to update
    await Future.delayed(Duration.zero);

    try {
      final logger = Logger.instance;
      logger.info(
        'Starting dependency resolution for ${_activeMods.length} active mods',
      );

      // Get current active mod count for comparison
      final initialActiveCount = modManager.activeMods.length;

      // Load required dependencies and get the load order
      final loadOrder = modManager.loadRequired();

      // Store any errors
      if (loadOrder.hasErrors) {
        setState(() {
          _loadOrderErrors = List<String>.from(loadOrder.errors);
        });

        logger.warning(
          'Found ${loadOrder.errors.length} errors during dependency loading',
        );
        for (final error in loadOrder.errors) {
          logger.warning('  - $error');
        }

        // Check for cycles
        setState(() {
          _hasCycles = loadOrder.errors.any(
            (e) => e.contains('Cyclic dependency'),
          );
          if (_hasCycles) {
            // Extract cycle info from error message
            final cycleError = loadOrder.errors.firstWhere(
              (e) => e.contains('Cyclic dependency'),
              orElse: () => '',
            );
            logger.warning('Detected dependency cycle: $cycleError');

            if (cycleError.isNotEmpty) {
              // Extract cycle path from error message
              final startIndex = cycleError.indexOf(':');
              if (startIndex != -1) {
                final pathStr = cycleError.substring(startIndex + 1).trim();
                _cycleInfo = pathStr.split(' -> ');
                logger.info(
                  'Extracted cycle path: ${_cycleInfo!.join(" -> ")}',
                );
              }
            }
          }
        });
      } else {
        _loadOrderErrors = null;
      }

      // Check for incompatibilities
      _incompatibleMods = modManager.checkIncompatibilities(
        modManager.activeMods.keys.toList(),
      );

      if (_incompatibleMods.isNotEmpty) {
        logger.warning(
          'Found ${_incompatibleMods.length} incompatible mod pairs:',
        );
        for (final pair in _incompatibleMods) {
          final mod1 = modManager.mods[pair[0]]?.name ?? pair[0];
          final mod2 = modManager.mods[pair[1]]?.name ?? pair[1];
          logger.warning('  - $mod1 is incompatible with $mod2');
        }
      }

      // Get sorted mods from the load order
      final List<Mod> sortedMods = [];
      for (final modId in loadOrder.loadOrder) {
        if (modManager.mods.containsKey(modId)) {
          sortedMods.add(modManager.mods[modId]!);
        }
      }

      // Calculate how many dependencies were added
      final newModsCount = modManager.activeMods.length - initialActiveCount;

      logger.info(
        'Dependency loading complete. Enabled $newModsCount new dependencies.',
      );
      if (newModsCount > 0) {
        logger.info('Newly enabled dependencies:');
        final activeModIds = modManager.activeMods.keys.toList();
        for (int i = 0; i < newModsCount; i++) {
          final modId = activeModIds[initialActiveCount + i];
          logger.info('  - ${modManager.mods[modId]?.name ?? modId} ($modId)');
        }
      }

      setState(() {
        _activeMods = sortedMods;
        _isLoading = false;
        if (newModsCount > 0) {
          _statusMessage = 'Added $newModsCount required dependencies!';
        } else {
          _statusMessage = 'All dependencies are already loaded.';
        }

        if (_hasCycles) {
          _statusMessage += ' Warning: Dependency cycles were found and fixed.';
        }
        if (_incompatibleMods.isNotEmpty) {
          _statusMessage +=
              ' Warning: ${_incompatibleMods.length} incompatible mod pairs found.';
        }
      });
    } catch (e) {
      Logger.instance.error('Error during dependency loading: $e');
      setState(() {
        _isLoading = false;
        _statusMessage = 'Error loading dependencies: $e';
      });
    }
  }
}

// Page for troubleshooting problematic mods
class TroubleshootingPage extends StatelessWidget {
  const TroubleshootingPage({super.key});

  @override
  Widget build(BuildContext context) {
    return const ModTroubleshooterWidget();
  }
}