flutter_server_box/lib/data/model/server/windows_parser.dart

import 'dart:convert';

import 'package:fl_lib/fl_lib.dart';
import 'package:intl/intl.dart';
import 'package:server_box/data/model/server/cpu.dart';
import 'package:server_box/data/model/server/disk.dart';
import 'package:server_box/data/model/server/memory.dart';
import 'package:server_box/data/model/server/server.dart';

/// Windows-specific status parsing utilities
/// 
/// This module handles parsing of Windows PowerShell command outputs
/// for server monitoring. It extracts the Windows parsing logic
/// to improve maintainability and readability.
class WindowsParser {
  const WindowsParser._();

  /// Parse Windows custom commands from segments
  static void parseCustomCommands(
    ServerStatus serverStatus,
    List<String> segments,
    Map<String, String> customCmds,
    int systemSegmentsLength,
  ) {
    try {
      for (int idx = 0; idx < customCmds.length; idx++) {
        final key = customCmds.keys.elementAt(idx);
        // Ensure we don't go out of bounds when accessing segments
        final segmentIndex = idx + systemSegmentsLength;
        if (segmentIndex < segments.length) {
          final value = segments[segmentIndex];
          serverStatus.customCmds[key] = value;
        } else {
          Loggers.app.warning(
            'Windows custom commands: segment index $segmentIndex out of bounds '
            '(segments length: ${segments.length}, systemSegmentsLength: $systemSegmentsLength)'
          );
        }
      }
    } catch (e, s) {
      Loggers.app.warning('Windows custom commands parsing failed: $e', s);
    }
  }

  /// Parse Windows uptime from PowerShell output
  static String? parseUpTime(String raw) {
    try {
      // Clean the input - trim whitespace and get the first non-empty line
      final cleanedInput = raw.trim().split('\n')
          .where((line) => line.trim().isNotEmpty)
          .firstOrNull;
      
      if (cleanedInput == null || cleanedInput.isEmpty) {
        Loggers.app.warning('Windows uptime parsing: empty or null input');
        return null;
      }
      
      // Try multiple date formats to handle different Windows locale/version outputs
      final formatters = [
        DateFormat('EEEE, MMMM d, yyyy h:mm:ss a', 'en_US'), // Original format
        DateFormat('EEEE, MMMM dd, yyyy h:mm:ss a', 'en_US'), // Double-digit day
        DateFormat('EEE, MMM d, yyyy h:mm:ss a', 'en_US'), // Shortened format
        DateFormat('EEE, MMM dd, yyyy h:mm:ss a', 'en_US'), // Shortened with double-digit day
        DateFormat('M/d/yyyy h:mm:ss a', 'en_US'), // Short US format
        DateFormat('MM/dd/yyyy h:mm:ss a', 'en_US'), // Short US format with zero padding
        DateFormat('d/M/yyyy h:mm:ss a', 'en_US'), // Short European format
        DateFormat('dd/MM/yyyy h:mm:ss a', 'en_US'), // Short European format with zero padding
      ];
      
      DateTime? dateTime;
      for (final formatter in formatters) {
        dateTime = formatter.tryParseLoose(cleanedInput);
        if (dateTime != null) break;
      }
      
      if (dateTime == null) {
        Loggers.app.warning('Windows uptime parsing: could not parse date format for: $cleanedInput');
        return null;
      }
      
      final now = DateTime.now();
      final uptime = now.difference(dateTime);
      
      // Validate that the uptime is reasonable (not negative, not too far in the future)
      if (uptime.isNegative || uptime.inDays > 3650) { // More than 10 years seems unreasonable
        Loggers.app.warning('Windows uptime parsing: unreasonable uptime calculated: ${uptime.inDays} days for date: $cleanedInput');
        return null;
      }

      final days = uptime.inDays;
      final hours = uptime.inHours % 24;
      final minutes = uptime.inMinutes % 60;

      if (days > 0) {
        return '$days days, $hours:${minutes.toString().padLeft(2, '0')}';
      } else {
        return '$hours:${minutes.toString().padLeft(2, '0')}';
      }
    } catch (e, s) {
      Loggers.app.warning('Windows uptime parsing failed: $e for input: $raw', s);
      return null;
    }
  }

  /// Parse Windows CPU information from PowerShell output
  static List<SingleCpuCore> parseCpu(String raw, ServerStatus serverStatus) {
    try {
      final dynamic jsonData = json.decode(raw);
      final List<SingleCpuCore> cpus = [];

      if (jsonData is List) {
        for (int i = 0; i < jsonData.length; i++) {
          final cpu = jsonData[i];
          final loadPercentage = cpu['LoadPercentage'] ?? 0;
          final usage = loadPercentage as int;
          final idle = 100 - usage;

          // Get previous CPU data to calculate cumulative values
          final prevCpus = serverStatus.cpu.now;
          final prevCpu = i < prevCpus.length ? prevCpus[i] : null;

          // LIMITATION: Windows CPU counters approach
          // PowerShell provides LoadPercentage as instantaneous percentage, not cumulative time.
          // We simulate cumulative counters by adding current percentages to previous totals.
          // This approach has limitations:
          // 1. Not as accurate as true cumulative time counters (Linux /proc/stat)
          // 2. May drift over time with variable polling intervals
          // 3. Results depend on consistent polling frequency
          // However, this allows compatibility with existing delta-based CPU calculation logic.
          final newUser = (prevCpu?.user ?? 0) + usage;
          final newIdle = (prevCpu?.idle ?? 0) + idle;

          cpus.add(
            SingleCpuCore(
              'cpu$i',
              newUser, // cumulative user time
              0, // sys (not available)
              0, // nice (not available)
              newIdle, // cumulative idle time
              0, // iowait (not available)
              0, // irq (not available)
              0, // softirq (not available)
            ),
          );
        }
      } else if (jsonData is Map) {
        // Single CPU core
        final loadPercentage = jsonData['LoadPercentage'] ?? 0;
        final usage = loadPercentage as int;
        final idle = 100 - usage;

        // Get previous CPU data to calculate cumulative values
        final prevCpus = serverStatus.cpu.now;
        final prevCpu = prevCpus.isNotEmpty ? prevCpus[0] : null;

        // LIMITATION: See comment above for Windows CPU counter limitations
        final newUser = (prevCpu?.user ?? 0) + usage;
        final newIdle = (prevCpu?.idle ?? 0) + idle;

        cpus.add(
          SingleCpuCore(
            'cpu0',
            newUser, // cumulative user time
            0, // sys
            0, // nice
            newIdle, // cumulative idle time
            0, // iowait
            0, // irq
            0, // softirq
          ),
        );
      }

      return cpus;
    } catch (e) {
      return [];
    }
  }

  /// Parse Windows memory information from PowerShell output
  /// 
  /// NOTE: Windows Win32_OperatingSystem properties TotalVisibleMemorySize 
  /// and FreePhysicalMemory are returned in KB units.
  static Memory? parseMemory(String raw) {
    try {
      final dynamic jsonData = json.decode(raw);
      final data = jsonData is List ? jsonData.first : jsonData;

      // Win32_OperatingSystem properties are in KB
      final totalKB = data['TotalVisibleMemorySize'] as int? ?? 0;
      final freeKB = data['FreePhysicalMemory'] as int? ?? 0;

      return Memory(
        total: totalKB,
        free: freeKB,
        avail: freeKB, // Windows doesn't distinguish between free and available
      );
    } catch (e) {
      return null;
    }
  }

  /// Parse Windows disk information from PowerShell output
  static List<Disk> parseDisks(String raw) {
    try {
      final dynamic jsonData = json.decode(raw);
      final List<Disk> disks = [];

      final diskList = jsonData is List ? jsonData : [jsonData];

      for (final diskData in diskList) {
        final deviceId = diskData['DeviceID']?.toString() ?? '';
        final size =
            BigInt.tryParse(diskData['Size']?.toString() ?? '0') ?? BigInt.zero;
        final freeSpace =
            BigInt.tryParse(diskData['FreeSpace']?.toString() ?? '0') ??
            BigInt.zero;
        final fileSystem = diskData['FileSystem']?.toString() ?? '';

        // Validate all required fields
        final hasRequiredFields = deviceId.isNotEmpty &&
            size != BigInt.zero &&
            freeSpace != BigInt.zero &&
            fileSystem.isNotEmpty;

        if (!hasRequiredFields) {
          Loggers.app.warning('Windows disk parsing: skipping disk with missing required fields. '
              'DeviceID: $deviceId, Size: $size, FreeSpace: $freeSpace, FileSystem: $fileSystem');
          continue;
        }

        final sizeKB = size ~/ BigInt.from(1024);
        final freeKB = freeSpace ~/ BigInt.from(1024);
        final usedKB = sizeKB - freeKB;
        final usedPercent = sizeKB > BigInt.zero
            ? ((usedKB * BigInt.from(100)) ~/ sizeKB).toInt()
            : 0;

        disks.add(
          Disk(
            path: deviceId,
            fsTyp: fileSystem,
            size: sizeKB,
            avail: freeKB,
            used: usedKB,
            usedPercent: usedPercent,
            mount: deviceId, // Windows uses drive letters as mount points
          ),
        );
      }

      return disks;
    } catch (e) {
      Loggers.app.warning('Windows disk parsing failed: $e');
      return [];
    }
  }
}