#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <DHT.h>
#include <Wire.h>
#include <BMP280.h>
#include <Adafruit_TSL2561_U.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Pin definitions
#define DHT_PIN 4
#define DHT_TYPE DHT22
#define SOIL_MOISTURE_PIN A0
#define SOIL_TEMP_PIN 2
#define RAIN_SENSOR_PIN 5
#define WIND_SPEED_PIN 18
#define WIND_DIR_PIN A1
#define BATTERY_PIN A2

// Sensor instances
DHT dht(DHT_PIN, DHT_TYPE);
BMP280 bmp;
Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);
OneWire oneWire(SOIL_TEMP_PIN);
DallasTemperature soilTemp(&oneWire);

// WiFi and MQTT configuration
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "your-mqtt-broker.com";
const char* mqtt_user = "your_mqtt_user";
const char* mqtt_password = "your_mqtt_password";

WiFiClient espClient;
PubSubClient client(espClient);

// Data structure
struct SensorData {
  float temperature;
  float humidity;
  float pressure;
  float light_level;
  float soil_moisture;
  float soil_temperature;
  bool rain_detected;
  float wind_speed;
  float wind_direction;
  float battery_voltage;
  unsigned long timestamp;
};

// Global variables
SensorData currentData;
unsigned long lastReading = 0;
unsigned long lastTransmission = 0;
const unsigned long READING_INTERVAL = 30000;  // 30 seconds
const unsigned long TRANSMISSION_INTERVAL = 300000;  // 5 minutes

void setup() {
  Serial.begin(115200);
  
  // Initialize sensors
  dht.begin();
  
  if (!bmp.begin()) {
    Serial.println("BMP280 sensor not found!");
  }
  
  if (!tsl.begin()) {
    Serial.println("TSL2561 sensor not found!");
  } else {
    tsl.enableAutoRange(true);
    tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);
  }
  
  soilTemp.begin();
  
  // Configure pins
  pinMode(RAIN_SENSOR_PIN, INPUT_PULLUP);
  pinMode(WIND_SPEED_PIN, INPUT_PULLUP);
  
  // Initialize WiFi and MQTT
  setupWiFi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(mqttCallback);
  
  Serial.println("Environmental Monitor initialized");
}

void loop() {
  if (!client.connected()) {
    reconnectMQTT();
  }
  client.loop();
  
  unsigned long now = millis();
  
  // Read sensors at regular intervals
  if (now - lastReading >= READING_INTERVAL) {
    readSensors();
    lastReading = now;
    
    // Display data locally
    displayData();
  }
  
  // Transmit data at longer intervals
  if (now - lastTransmission >= TRANSMISSION_INTERVAL) {
    transmitData();
    lastTransmission = now;
  }
  
  // Check for alerts
  checkAlerts();
  
  delay(1000);
}

void setupWiFi() {
  delay(10);
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnectMQTT() {
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_password)) {
      Serial.println("connected");
      client.subscribe("envmonitor/commands");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void readSensors() {
  currentData.timestamp = WiFi.getTime();
  
  // DHT22 - Temperature and Humidity
  currentData.temperature = dht.readTemperature();
  currentData.humidity = dht.readHumidity();
  
  // BMP280 - Pressure
  currentData.pressure = bmp.readPressure() / 100.0F;  // Convert to hPa
  
  // TSL2561 - Light Level
  sensors_event_t event;
  tsl.getEvent(&event);
  currentData.light_level = event.light;
  
  // Soil moisture (capacitive sensor)
  int soilMoistureRaw = analogRead(SOIL_MOISTURE_PIN);
  currentData.soil_moisture = map(soilMoistureRaw, 0, 4095, 100, 0);  // Convert to percentage
  
  // Soil temperature
  soilTemp.requestTemperatures();
  currentData.soil_temperature = soilTemp.getTempCByIndex(0);
  
  // Rain detection
  currentData.rain_detected = !digitalRead(RAIN_SENSOR_PIN);
  
  // Wind speed (anemometer with hall effect sensor)
  currentData.wind_speed = measureWindSpeed();
  
  // Wind direction (potentiometer-based wind vane)
  int windDirRaw = analogRead(WIND_DIR_PIN);
  currentData.wind_direction = map(windDirRaw, 0, 4095, 0, 360);
  
  // Battery voltage
  int batteryRaw = analogRead(BATTERY_PIN);
  currentData.battery_voltage = (batteryRaw * 3.3 * 2) / 4095.0;  // Voltage divider
}

float measureWindSpeed() {
  // Simple wind speed measurement using interrupt counting
  // This is a simplified version - real implementation would use interrupts
  static unsigned long lastWindMeasure = 0;
  static int windPulseCount = 0;
  
  unsigned long now = millis();
  if (now - lastWindMeasure >= 10000) {  // 10 second measurement window
    // Convert pulse count to wind speed (calibration dependent)
    float windSpeed = windPulseCount * 0.33;  // Example conversion factor
    windPulseCount = 0;
    lastWindMeasure = now;
    return windSpeed;
  }
  
  return currentData.wind_speed;  // Return previous value
}

void displayData() {
  Serial.println("=== Environmental Data ===");
  Serial.printf("Temperature: %.1f°C\n", currentData.temperature);
  Serial.printf("Humidity: %.1f%%\n", currentData.humidity);
  Serial.printf("Pressure: %.1f hPa\n", currentData.pressure);
  Serial.printf("Light: %.1f lux\n", currentData.light_level);
  Serial.printf("Soil Moisture: %.1f%%\n", currentData.soil_moisture);
  Serial.printf("Soil Temperature: %.1f°C\n", currentData.soil_temperature);
  Serial.printf("Rain: %s\n", currentData.rain_detected ? "Yes" : "No");
  Serial.printf("Wind Speed: %.1f m/s\n", currentData.wind_speed);
  Serial.printf("Wind Direction: %.0f°\n", currentData.wind_direction);
  Serial.printf("Battery: %.2fV\n", currentData.battery_voltage);
  Serial.println("========================");
}

void transmitData() {
  // Create JSON payload
  DynamicJsonDocument doc(1024);
  doc["device_id"] = "ENV_MONITOR_001";
  doc["timestamp"] = currentData.timestamp;
  doc["temperature"] = currentData.temperature;
  doc["humidity"] = currentData.humidity;
  doc["pressure"] = currentData.pressure;
  doc["light_level"] = currentData.light_level;
  doc["soil_moisture"] = currentData.soil_moisture;
  doc["soil_temperature"] = currentData.soil_temperature;
  doc["rain_detected"] = currentData.rain_detected;
  doc["wind_speed"] = currentData.wind_speed;
  doc["wind_direction"] = currentData.wind_direction;
  doc["battery_voltage"] = currentData.battery_voltage;
  
  char buffer[1024];
  serializeJson(doc, buffer);
  
  // Publish to MQTT
  if (client.publish("envmonitor/data", buffer)) {
    Serial.println("Data transmitted successfully");
  } else {
    Serial.println("Failed to transmit data");
  }
}

void checkAlerts() {
  // Temperature alerts
  if (currentData.temperature > 35.0 || currentData.temperature < -5.0) {
    sendAlert("TEMPERATURE", "Temperature out of normal range");
  }
  
  // Humidity alerts
  if (currentData.humidity > 90.0 || currentData.humidity < 20.0) {
    sendAlert("HUMIDITY", "Humidity out of normal range");
  }
  
  // Soil moisture alerts
  if (currentData.soil_moisture < 20.0) {
    sendAlert("SOIL_MOISTURE", "Soil moisture critically low");
  }
  
  // Battery alerts
  if (currentData.battery_voltage < 3.3) {
    sendAlert("BATTERY", "Battery voltage low");
  }
  
  // Rain alerts
  if (currentData.rain_detected) {
    sendAlert("WEATHER", "Rain detected");
  }
}

void sendAlert(const char* type, const char* message) {
  DynamicJsonDocument alert(256);
  alert["device_id"] = "ENV_MONITOR_001";
  alert["alert_type"] = type;
  alert["message"] = message;
  alert["timestamp"] = currentData.timestamp;
  alert["severity"] = "WARNING";
  
  char buffer[256];
  serializeJson(alert, buffer);
  
  client.publish("envmonitor/alerts", buffer);
  Serial.printf("ALERT: %s - %s\n", type, message);
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String message;
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  Serial.printf("Received command: %s\n", message.c_str());
  
  // Parse commands
  if (message == "STATUS") {
    transmitData();
  } else if (message == "RESET") {
    ESP.restart();
  } else if (message.startsWith("INTERVAL:")) {
    // Change transmission interval
    int newInterval = message.substring(9).toInt();
    if (newInterval >= 60) {  // Minimum 1 minute
      // Update interval (implementation depends on requirements)
      Serial.printf("Interval changed to %d seconds\n", newInterval);
    }
  }
}

import json
import sqlite3
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import paho.mqtt.client as mqtt
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
import warnings
warnings.filterwarnings('ignore')

class EnvironmentalDataProcessor:
    def __init__(self, db_path='environmental_data.db', mqtt_broker='localhost'):
        self.db_path = db_path
        self.mqtt_broker = mqtt_broker
        self.setup_database()
        self.setup_mqtt()
        
    def setup_database(self):
        """Initialize SQLite database for storing sensor data"""
        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
        self.cursor = self.conn.cursor()
        
        # Create tables
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS sensor_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                device_id TEXT NOT NULL,
                timestamp DATETIME NOT NULL,
                temperature REAL,
                humidity REAL,
                pressure REAL,
                light_level REAL,
                soil_moisture REAL,
                soil_temperature REAL,
                rain_detected INTEGER,
                wind_speed REAL,
                wind_direction REAL,
                battery_voltage REAL
            )
        ''')
        
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS alerts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                device_id TEXT NOT NULL,
                timestamp DATETIME NOT NULL,
                alert_type TEXT NOT NULL,
                message TEXT NOT NULL,
                severity TEXT NOT NULL,
                acknowledged INTEGER DEFAULT 0
            )
        ''')
        
        self.conn.commit()
        
    def setup_mqtt(self):
        """Setup MQTT client for receiving data"""
        self.mqtt_client = mqtt.Client()
        self.mqtt_client.on_connect = self.on_mqtt_connect
        self.mqtt_client.on_message = self.on_mqtt_message
        
        try:
            self.mqtt_client.connect(self.mqtt_broker, 1883, 60)
            self.mqtt_client.loop_start()
        except Exception as e:
            print(f"MQTT connection failed: {e}")
            
    def on_mqtt_connect(self, client, userdata, flags, rc):
        """Callback for MQTT connection"""
        if rc == 0:
            print("Connected to MQTT broker")
            client.subscribe("envmonitor/data")
            client.subscribe("envmonitor/alerts")
        else:
            print(f"Failed to connect to MQTT broker: {rc}")
            
    def on_mqtt_message(self, client, userdata, msg):
        """Process incoming MQTT messages"""
        try:
            topic = msg.topic
            payload = json.loads(msg.payload.decode())
            
            if topic == "envmonitor/data":
                self.store_sensor_data(payload)
            elif topic == "envmonitor/alerts":
                self.store_alert(payload)
                
        except Exception as e:
            print(f"Error processing MQTT message: {e}")
            
    def store_sensor_data(self, data):
        """Store sensor data in database"""
        try:
            self.cursor.execute('''
                INSERT INTO sensor_data (
                    device_id, timestamp, temperature, humidity, pressure,
                    light_level, soil_moisture, soil_temperature, rain_detected,
                    wind_speed, wind_direction, battery_voltage
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                data['device_id'],
                datetime.fromtimestamp(data['timestamp']),
                data['temperature'],
                data['humidity'],
                data['pressure'],
                data['light_level'],
                data['soil_moisture'],
                data['soil_temperature'],
                int(data['rain_detected']),
                data['wind_speed'],
                data['wind_direction'],
                data['battery_voltage']
            ))
            
            self.conn.commit()
            print(f"Stored data from {data['device_id']}")
            
        except Exception as e:
            print(f"Error storing sensor data: {e}")
            
    def store_alert(self, alert):
        """Store alert in database"""
        try:
            self.cursor.execute('''
                INSERT INTO alerts (
                    device_id, timestamp, alert_type, message, severity
                ) VALUES (?, ?, ?, ?, ?)
            ''', (
                alert['device_id'],
                datetime.fromtimestamp(alert['timestamp']),
                alert['alert_type'],
                alert['message'],
                alert['severity']
            ))
            
            self.conn.commit()
            print(f"Stored alert: {alert['message']}")
            
            # Send email notification for critical alerts
            if alert['severity'] in ['CRITICAL', 'WARNING']:
                self.send_email_alert(alert)
                
        except Exception as e:
            print(f"Error storing alert: {e}")
            
    def get_recent_data(self, device_id, hours=24):
        """Retrieve recent sensor data"""
        since = datetime.now() - timedelta(hours=hours)
        
        query = '''
            SELECT * FROM sensor_data 
            WHERE device_id = ? AND timestamp >= ?
            ORDER BY timestamp DESC
        '''
        
        df = pd.read_sql_query(query, self.conn, params=(device_id, since))
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        return df
        
    def generate_statistics(self, device_id, hours=24):
        """Generate statistical summary of recent data"""
        df = self.get_recent_data(device_id, hours)
        
        if df.empty:
            return None
            
        numeric_columns = [
            'temperature', 'humidity', 'pressure', 'light_level',
            'soil_moisture', 'soil_temperature', 'wind_speed',
            'wind_direction', 'battery_voltage'
        ]
        
        stats_dict = {}
        
        for col in numeric_columns:
            if col in df.columns:
                stats_dict[col] = {
                    'current': df[col].iloc[0] if not df.empty else None,
                    'mean': df[col].mean(),
                    'min': df[col].min(),
                    'max': df[col].max(),
                    'std': df[col].std()
                }
        
        # Add derived statistics
        stats_dict['data_points'] = len(df)
        stats_dict['rain_percentage'] = (df['rain_detected'].sum() / len(df)) * 100
        stats_dict['time_range'] = {
            'start': df['timestamp'].min().isoformat(),
            'end': df['timestamp'].max().isoformat()
        }
        
        return stats_dict
        
    def detect_anomalies(self, device_id, hours=168):  # 1 week
        """Detect anomalies in sensor data using statistical methods"""
        df = self.get_recent_data(device_id, hours)
        
        if len(df) < 50:  # Need sufficient data for anomaly detection
            return []
            
        anomalies = []
        
        # Temperature anomaly detection using Z-score
        if 'temperature' in df.columns:
            z_scores = np.abs(stats.zscore(df['temperature'].dropna()))
            temp_anomalies = df[z_scores > 3]  # 3 standard deviations
            
            for _, row in temp_anomalies.iterrows():
                anomalies.append({
                    'timestamp': row['timestamp'].isoformat(),
                    'type': 'temperature',
                    'value': row['temperature'],
                    'severity': 'HIGH' if abs(stats.zscore([row['temperature']])[0]) > 4 else 'MEDIUM'
                })
        
        # Humidity anomaly detection
        if 'humidity' in df.columns:
            z_scores = np.abs(stats.zscore(df['humidity'].dropna()))
            humidity_anomalies = df[z_scores > 3]
            
            for _, row in humidity_anomalies.iterrows():
                anomalies.append({
                    'timestamp': row['timestamp'].isoformat(),
                    'type': 'humidity',
                    'value': row['humidity'],
                    'severity': 'MEDIUM'
                })
        
        # Sudden changes detection (gradient-based)
        for column in ['temperature', 'humidity', 'pressure']:
            if column in df.columns:
                gradient = np.gradient(df[column].dropna())
                sudden_changes = np.where(np.abs(gradient) > 2 * np.std(gradient))[0]
                
                for idx in sudden_changes:
                    if idx < len(df):
                        anomalies.append({
                            'timestamp': df.iloc[idx]['timestamp'].isoformat(),
                            'type': f'{column}_sudden_change',
                            'value': df.iloc[idx][column],
                            'gradient': gradient[idx],
                            'severity': 'MEDIUM'
                        })
        
        return anomalies
        
    def generate_report(self, device_id, hours=24):
        """Generate comprehensive data report"""
        df = self.get_recent_data(device_id, hours)
        stats = self.generate_statistics(device_id, hours)
        anomalies = self.detect_anomalies(device_id)
        
        report = {
            'device_id': device_id,
            'report_time': datetime.now().isoformat(),
            'data_period_hours': hours,
            'statistics': stats,
            'anomalies': anomalies,
            'data_quality': self.assess_data_quality(df)
        }
        
        return report
        
    def assess_data_quality(self, df):
        """Assess the quality of collected data"""
        if df.empty:
            return {'status': 'NO_DATA', 'score': 0}
            
        total_points = len(df)
        missing_points = df.isnull().sum().sum()
        completeness = 1 - (missing_points / (total_points * len(df.columns)))
        
        # Check data freshness
        latest_data = df['timestamp'].max()
        time_since_last = (datetime.now() - latest_data).total_seconds() / 3600
        freshness = max(0, 1 - (time_since_last / 24))  # Degrade over 24 hours
        
        # Overall quality score
        quality_score = (completeness * 0.7 + freshness * 0.3) * 100
        
        status = 'EXCELLENT' if quality_score > 90 else \
                'GOOD' if quality_score > 70 else \
                'FAIR' if quality_score > 50 else 'POOR'
        
        return {
            'status': status,
            'score': round(quality_score, 1),
            'completeness': round(completeness * 100, 1),
            'freshness': round(freshness * 100, 1),
            'total_points': total_points,
            'missing_points': missing_points
        }
        
    def send_email_alert(self, alert):
        """Send email notification for alerts"""
        # Email configuration (would be loaded from config file)
        smtp_server = "smtp.gmail.com"
        smtp_port = 587
        sender_email = "your-email@gmail.com"
        sender_password = "your-app-password"
        recipient_email = "recipient@gmail.com"
        
        try:
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = recipient_email
            msg['Subject'] = f"Environmental Monitor Alert: {alert['alert_type']}"
            
            body = f"""
            Alert from Environmental Monitoring System
            
            Device: {alert['device_id']}
            Time: {datetime.fromtimestamp(alert['timestamp'])}
            Type: {alert['alert_type']}
            Severity: {alert['severity']}
            Message: {alert['message']}
            
            Please check the monitoring dashboard for more details.
            """
            
            msg.attach(MIMEText(body, 'plain'))
            
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.starttls()
            server.login(sender_email, sender_password)
            server.send_message(msg)
            server.quit()
            
            print(f"Email alert sent for {alert['alert_type']}")
            
        except Exception as e:
            print(f"Failed to send email alert: {e}")

# Example usage
if __name__ == "__main__":
    processor = EnvironmentalDataProcessor()
    
    # Generate report for the last 24 hours
    report = processor.generate_report("ENV_MONITOR_001", 24)
    print(json.dumps(report, indent=2))
    
    # Keep the processor running to receive MQTT messages
    try:
        while True:
            time.sleep(60)  # Run every minute
    except KeyboardInterrupt:
        print("Shutting down data processor...")
        processor.conn.close()