Core/Services/ElectromagneticDetectionService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using static BlockchainNetworkAnalyzer.App;

namespace BlockchainNetworkAnalyzer.Core.Services
{
    /// <summary>
    /// Advanced electromagnetic and radio frequency detection service for cryptocurrency miners
    /// </summary>
    public class ElectromagneticDetectionService : IDisposable
    {
        private readonly ILogger<ElectromagneticDetectionService> _logger;
        private CancellationTokenSource _cancellationTokenSource;
        private bool _isScanning;
        private readonly List<MinerSignal> _detectedSignals = new List<MinerSignal>();
        private readonly MinerFrequencyDatabase _frequencyDatabase;

        public event EventHandler<MinerSignalDetectedEventArgs> SignalDetected;
        public event EventHandler<ScanProgressEventArgs> ScanProgress;

        public ElectromagneticDetectionService()
        {
            _logger = App.LoggerFactory.CreateLogger<ElectromagneticDetectionService>();
            _frequencyDatabase = new MinerFrequencyDatabase();
            InitializeFrequencyDatabase();
        }

        private void InitializeFrequencyDatabase()
        {
            // Load known miner frequency signatures
            _frequencyDatabase.LoadMinerFrequencies();
        }

        /// <summary>
        /// Start continuous scanning for miner electromagnetic signatures
        /// </summary>
        public async Task StartScanningAsync(int scanDurationSeconds = 60)
        {
            if (_isScanning)
            {
                _logger.LogWarning("Scan already in progress");
                return;
            }

            _isScanning = true;
            _cancellationTokenSource = new CancellationTokenSource();
            _detectedSignals.Clear();

            try
            {
                _logger.LogInformation("Starting electromagnetic scan for miners...");
                
                var startTime = DateTime.Now;
                var endTime = startTime.AddSeconds(scanDurationSeconds);

                // Multi-threaded scanning for different frequency ranges
                var scanTasks = new List<Task>
                {
                    ScanRadioFrequencyRange(50.0, 200.0, _cancellationTokenSource.Token), // Low frequency range
                    ScanRadioFrequencyRange(200.0, 500.0, _cancellationTokenSource.Token), // Mid frequency range
                    ScanRadioFrequencyRange(500.0, 1000.0, _cancellationTokenSource.Token), // High frequency range
                    ScanElectromagneticField(_cancellationTokenSource.Token),
                    ScanPowerLineNoise(_cancellationTokenSource.Token)
                };

                // Monitor scan progress
                var progressTask = MonitorScanProgress(startTime, endTime, _cancellationTokenSource.Token);

                await Task.WhenAll(scanTasks);
                await progressTask;

                _logger.LogInformation($"Scan completed. Detected {_detectedSignals.Count} miner signals");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error during electromagnetic scan");
            }
            finally
            {
                _isScanning = false;
            }
        }

        private async Task ScanRadioFrequencyRange(double minFreq, double maxFreq, CancellationToken cancellationToken)
        {
            await Task.Run(async () =>
            {
                try
                {
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        // Simulate RF scanning - in production, would use actual RF hardware APIs
                        var detectedFreq = await ScanFrequencyRangeAsync(minFreq, maxFreq);
                        
                        if (detectedFreq != null && _frequencyDatabase.IsMinerFrequency(detectedFreq.Frequency))
                        {
                            var minerSignal = new MinerSignal
                            {
                                Frequency = detectedFreq.Frequency,
                                Amplitude = detectedFreq.Amplitude,
                                SignalType = SignalType.RadioFrequency,
                                Timestamp = DateTime.Now,
                                SignalStrength = CalculateSignalStrength(detectedFreq.Amplitude),
                                Confidence = _frequencyDatabase.GetConfidence(detectedFreq.Frequency)
                            };

                            // Estimate distance based on signal strength
                            minerSignal.EstimatedDistance = EstimateDistance(minerSignal.SignalStrength, minerSignal.Frequency);

                            lock (_detectedSignals)
                            {
                                _detectedSignals.Add(minerSignal);
                            }

                            OnSignalDetected(new MinerSignalDetectedEventArgs(minerSignal));
                        }

                        await Task.Delay(100, cancellationToken);
                    }
                }
                catch (OperationCanceledException)
                {
                    // Expected when cancelled
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, $"Error scanning RF range {minFreq}-{maxFreq} MHz");
                }
            }, cancellationToken);
        }

        private async Task ScanElectromagneticField(CancellationToken cancellationToken)
        {
            await Task.Run(async () =>
            {
                try
                {
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        // Detect electromagnetic field variations
                        var emField = await DetectEMFieldAsync();
                        
                        if (emField != null && IsMinerEMSignature(emField))
                        {
                            var minerSignal = new MinerSignal
                            {
                                SignalType = SignalType.ElectromagneticField,
                                Timestamp = DateTime.Now,
                                EMFieldStrength = emField.Strength,
                                Frequency = emField.DominantFrequency,
                                SignalStrength = CalculateEMSignalStrength(emField.Strength),
                                Confidence = 0.85,
                                EstimatedDistance = EstimateDistanceFromEM(emField.Strength)
                            };

                            lock (_detectedSignals)
                            {
                                _detectedSignals.Add(minerSignal);
                            }

                            OnSignalDetected(new MinerSignalDetectedEventArgs(minerSignal));
                        }

                        await Task.Delay(50, cancellationToken);
                    }
                }
                catch (OperationCanceledException) { }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error scanning electromagnetic field");
                }
            }, cancellationToken);
        }

        private async Task ScanPowerLineNoise(CancellationToken cancellationToken)
        {
            await Task.Run(async () =>
            {
                try
                {
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        // Detect power line noise patterns characteristic of miners
                        var powerNoise = await DetectPowerLineNoiseAsync();
                        
                        if (powerNoise != null && _frequencyDatabase.MatchesMinerPowerSignature(powerNoise))
                        {
                            var minerSignal = new MinerSignal
                            {
                                SignalType = SignalType.PowerLineNoise,
                                Timestamp = DateTime.Now,
                                Frequency = powerNoise.DominantFrequency,
                                SignalStrength = powerNoise.NoiseLevel,
                                Confidence = 0.75,
                                EstimatedDistance = EstimateDistanceFromPowerNoise(powerNoise.NoiseLevel)
                            };

                            lock (_detectedSignals)
                            {
                                _detectedSignals.Add(minerSignal);
                            }

                            OnSignalDetected(new MinerSignalDetectedEventArgs(minerSignal));
                        }

                        await Task.Delay(200, cancellationToken);
                    }
                }
                catch (OperationCanceledException) { }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error scanning power line noise");
                }
            }, cancellationToken);
        }

        private async Task<FrequencyReading> ScanFrequencyRangeAsync(double minFreq, double maxFreq)
        {
            // In production, this would interface with RF hardware
            // For now, simulate detection of known miner frequencies
            
            await Task.Delay(10); // Simulate scan time

            var knownFrequencies = _frequencyDatabase.GetKnownFrequenciesInRange(minFreq, maxFreq);
            if (knownFrequencies.Any())
            {
                var freq = knownFrequencies.First();
                // Simulate signal detection
                var random = new Random();
                var amplitude = 50 + random.NextDouble() * 50; // Random amplitude 50-100

                return new FrequencyReading
                {
                    Frequency = freq,
                    Amplitude = amplitude,
                    Phase = random.NextDouble() * 2 * Math.PI
                };
            }

            return null;
        }

        private async Task<EMFieldReading> DetectEMFieldAsync()
        {
            await Task.Delay(10);

            // Simulate EM field detection
            // In production, would use magnetometer APIs
            var random = new Random();
            if (random.NextDouble() > 0.9) // 10% chance of detection
            {
                return new EMFieldReading
                {
                    Strength = 10 + random.NextDouble() * 90,
                    DominantFrequency = 100 + random.NextDouble() * 400
                };
            }

            return null;
        }

        private async Task<PowerNoiseReading> DetectPowerLineNoiseAsync()
        {
            await Task.Delay(20);

            // Simulate power line noise detection
            var random = new Random();
            if (random.NextDouble() > 0.85) // 15% chance
            {
                return new PowerNoiseReading
                {
                    NoiseLevel = 20 + random.NextDouble() * 80,
                    DominantFrequency = 50 + random.NextDouble() * 200, // 50-250 Hz typical
                    HarmonicPattern = GenerateHarmonicPattern()
                };
            }

            return null;
        }

        private bool IsMinerEMSignature(EMFieldReading reading)
        {
            // Check if EM field pattern matches known miner signatures
            return _frequencyDatabase.MatchesEMSignature(reading.DominantFrequency, reading.Strength);
        }

        private double CalculateSignalStrength(double amplitude)
        {
            // Convert amplitude to signal strength (0-100)
            return Math.Min(100, amplitude);
        }

        private double CalculateEMSignalStrength(double fieldStrength)
        {
            return Math.Min(100, fieldStrength);
        }

        private double EstimateDistance(double signalStrength, double frequency)
        {
            // Estimate distance based on signal strength and frequency
            // Using free-space path loss model: L = 20*log10(d) + 20*log10(f) + 32.44
            // Simplified: distance ≈ 10^((32.44 + 20*log10(f) - signalLoss)/20)
            
            var signalLoss = 100 - signalStrength; // dB
            var distanceKm = Math.Pow(10, (32.44 + 20 * Math.Log10(frequency) - signalLoss) / 20);
            
            // Convert to meters and clamp to reasonable range
            var distanceM = Math.Max(1, Math.Min(10000, distanceKm * 1000));
            
            return distanceM;
        }

        private double EstimateDistanceFromEM(double fieldStrength)
        {
            // Inverse square law: field strength ∝ 1/distance²
            // distance ≈ sqrt(constant / fieldStrength)
            var constant = 10000; // Calibration constant
            return Math.Sqrt(constant / Math.Max(1, fieldStrength));
        }

        private double EstimateDistanceFromPowerNoise(double noiseLevel)
        {
            // Similar estimation for power line noise
            var constant = 5000;
            return Math.Sqrt(constant / Math.Max(1, noiseLevel));
        }

        private double[] GenerateHarmonicPattern()
        {
            // Generate harmonic pattern typical of miner power consumption
            return new double[] { 50, 100, 150, 200, 250 }; // 50Hz harmonics
        }

        private async Task MonitorScanProgress(DateTime startTime, DateTime endTime, CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested && DateTime.Now < endTime)
            {
                var elapsed = (DateTime.Now - startTime).TotalSeconds;
                var total = (endTime - startTime).TotalSeconds;
                var progress = (elapsed / total) * 100;

                OnScanProgress(new ScanProgressEventArgs
                {
                    Progress = (int)progress,
                    SignalsDetected = _detectedSignals.Count,
                    Message = $"Scanning... {_detectedSignals.Count} signals detected"
                });

                await Task.Delay(1000, cancellationToken);
            }
        }

        public void StopScanning()
        {
            _cancellationTokenSource?.Cancel();
            _isScanning = false;
        }

        public List<MinerSignal> GetDetectedSignals()
        {
            lock (_detectedSignals)
            {
                return new List<MinerSignal>(_detectedSignals);
            }
        }

        protected virtual void OnSignalDetected(MinerSignalDetectedEventArgs e)
        {
            SignalDetected?.Invoke(this, e);
        }

        protected virtual void OnScanProgress(ScanProgressEventArgs e)
        {
            ScanProgress?.Invoke(this, e);
        }

        public void Dispose()
        {
            StopScanning();
            _cancellationTokenSource?.Dispose();
        }
    }

    // Supporting classes and enums
    public enum SignalType
    {
        RadioFrequency,
        ElectromagneticField,
        PowerLineNoise,
        Acoustic,
        Ultrasonic
    }

    public class MinerSignal
    {
        public SignalType SignalType { get; set; }
        public double Frequency { get; set; } // Hz or MHz depending on type
        public double Amplitude { get; set; }
        public double SignalStrength { get; set; } // 0-100
        public double Confidence { get; set; } // 0-1
        public double EstimatedDistance { get; set; } // meters
        public DateTime Timestamp { get; set; }
        public double? EMFieldStrength { get; set; }
        public string MinerType { get; set; }
        public double? Bearing { get; set; } // Direction in degrees (0-360)
        public double? Elevation { get; set; } // Vertical angle
    }

    public class MinerSignalDetectedEventArgs : EventArgs
    {
        public MinerSignal Signal { get; }

        public MinerSignalDetectedEventArgs(MinerSignal signal)
        {
            Signal = signal;
        }
    }

    public class ScanProgressEventArgs : EventArgs
    {
        public int Progress { get; set; }
        public int SignalsDetected { get; set; }
        public string Message { get; set; }
    }

    public class FrequencyReading
    {
        public double Frequency { get; set; }
        public double Amplitude { get; set; }
        public double Phase { get; set; }
    }

    public class EMFieldReading
    {
        public double Strength { get; set; }
        public double DominantFrequency { get; set; }
    }

    public class PowerNoiseReading
    {
        public double NoiseLevel { get; set; }
        public double DominantFrequency { get; set; }
        public double[] HarmonicPattern { get; set; }
    }
}