using ModVersionChecker.model;
using ModVersionChecker.managers.interfaces;
using ModVersionChecker.service.interfaces;


namespace ModVersionChecker
{
    public class VersionChecker
    {
        private readonly IConfigManager _configManager;
        private readonly IVersionService _versionService;

        public event EventHandler<string>? OnFinished;

        public VersionChecker(
            IVersionService versionService,
            IConfigManager configManager)
        {
            _configManager = configManager ?? throw new ArgumentNullException(nameof(configManager));
            _versionService = versionService ?? throw new ArgumentNullException(nameof(versionService));
        }
        
        //private void HandleAppError(string message, AppConfig app)
        //{
        //    errorMessages.Add(message);
        //    _appsManager.UpdateStatus(app, AppStatus.ERROR);
        //}   

        public void StartVersionChecking()
        {
            var config = _configManager.Load() ?? new Config();
            // Run version checks in a background thread
            new Thread(async () =>
            {
                while (true)
                {
                    await _versionService.CheckAllApps();

                    Thread.Sleep(config.IntervalMinutes * 60 * 1000);
                }

            })
            { IsBackground = true }.Start();
        }

       

        //public async Task CheckAsync()
        //{
        //    var config = _configManager.Load() ?? new GlobalConfig();
        //    var apps = _appsManager.Load() ?? new List<AppConfig>();
        //    var sources = _sourcesDefManager.List() ?? new List<SourceDef>();
        //    var fsMods = _fsManager.Load() ?? new List<TypeDef>();
        //    var types = _typeConfigManager.GetTypeConfigs() ?? new List<TypeConfig>();

        //    var appVersionsMap = await _apiVersionService.GetAppVersionsAsync(apps);

        //    updateMessages = new List<string>();
        //    errorMessages = new List<string>();

        //    foreach (AppConfig app in apps)
        //    {
        //        if (app.Status != AppStatus.ERROR && app.LastCheckedAt != 0 && app.LastCheckedAt < TimeUtils.GetUnixTimeMillis(DateTime.Now.AddMinutes(-60)))
        //            continue; 

        //        var status = AppStatus.NONE;
        //        var sourceId = app.Source;

        //        // Skip apps that are not in the API response

        //        if (!appVersionsMap.Any(a => app.Id == a.Id)) {
        //            continue;
        //        }
        //        var latesstVersion = appVersionsMap.FirstOrDefault(a => a.Id == app.Id).LatestVersion;
        //        if (string.IsNullOrWhiteSpace(sourceId))
        //        {
        //            HandleAppError($"{app.Name} has no source configured.", app);
        //            continue;
        //        }
        //        var source = sources.FirstOrDefault(s => s.Id == sourceId);
        //        if (source == null)
        //        {
        //            HandleAppError($"{app.Name} has an invalid source: {sourceId}", app);
        //            continue;
        //        }
        //        try
        //        {
        //            var type = app.Types[0];
        //            var typeConfig = types[0];
        //            if (typeConfig == null)
        //            {
        //                HandleAppError($"{app.Name} has no FS mod path configured for version {type}.", app);
        //                continue;
        //            }
        //            var current = NuGetVersion.Parse(VersionUtils.GetCurrentVersion(app, typeConfig));
        //            var latest = NuGetVersion.Parse(latesstVersion);

        //            app.CurrentVersion = current.ToString();
        //            app.LatestVersion = latest.ToString();

        //            if (latest.CompareTo(current) == 1)
        //            {
        //                updateMessages.Add($"{app.Name}: New version {latest} (current: {current})");
        //                status = AppStatus.UPDATE_AVAILABLE;
        //            }
                    
        //            _appsManager.UpdateStatus(app, status);
        //        }
        //        catch (Exception ex)
        //        {
        //            HandleAppError($"Failed for {app.Name}: {ex.Message}", app);
        //        }
        //    }

        //    if (updateMessages.Count > 0)
        //    {
        //        _notifyIconService.ShowBalloonTip(
        //            10000,
        //            "Updates Available",
        //            string.Join("\n", updateMessages),
        //            ToolTipIcon.Info
        //        );
        //    }
        //    if (errorMessages.Count > 0)
        //    {
        //        _notifyIconService.ShowBalloonTip(
        //            10000,
        //            "Errors",
        //            string.Join("\n", errorMessages),
        //            ToolTipIcon.Error
        //        );
        //    }
        //    OnFinished?.Invoke(this, "Version check completed.");
        //}
    }
}