from flask import (
    Flask,
    render_template,
    request,
    jsonify,
    redirect,
    url_for,
    send_from_directory,
)
import snap7
import snap7.util
import json
import socket
import time
import logging
import threading
from datetime import datetime
from typing import Dict, Any, Optional, List
import struct
import os
import csv
from pathlib import Path
import atexit
import psutil
import sys
from core.plc_client import PLCDataStreamer

app = Flask(__name__)
app.secret_key = "plc_streamer_secret_key"

def resource_path(relative_path):
    """ Get absolute path to resource, works for dev and for PyInstaller """
    try:
        # PyInstaller creates a temp folder and stores path in _MEIPASS
        base_path = sys._MEIPASS
    except Exception:
        # Not running in a bundle
        base_path = os.path.abspath(".")

    return os.path.join(base_path, relative_path)


# Global streamer instance (will be initialized in main)
streamer = None


def check_streamer_initialized():
    """Check if streamer is initialized, return error response if not"""
    if streamer is None:
        return jsonify({"error": "Application not initialized"}), 503
    return None


@app.route("/images/<filename>")
def serve_image(filename):
    """Serve images from .images directory"""
    return send_from_directory(".images", filename)


@app.route("/")
def index():
    """Main page"""
    if streamer is None:
        return "Application not initialized", 503

    # Get variables for the current dataset or empty dict if no current dataset
    current_variables = {}
    if streamer.current_dataset_id and streamer.current_dataset_id in streamer.datasets:
        current_variables = streamer.datasets[streamer.current_dataset_id].get(
            "variables", {}
        )

    return render_template(
        "index.html",
        status=streamer.get_status(),
        variables=current_variables,
        datasets=streamer.datasets,
        current_dataset_id=streamer.current_dataset_id,
    )


@app.route("/api/plc/config", methods=["POST"])
def update_plc_config():
    """Update PLC configuration"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        data = request.get_json()
        ip = data.get("ip", "10.1.33.11")
        rack = int(data.get("rack", 0))
        slot = int(data.get("slot", 2))

        streamer.update_plc_config(ip, rack, slot)
        return jsonify({"success": True, "message": "PLC configuration updated"})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/udp/config", methods=["POST"])
def update_udp_config():
    """Update UDP configuration"""
    try:
        data = request.get_json()
        host = data.get("host", "127.0.0.1")
        port = int(data.get("port", 9870))

        streamer.update_udp_config(host, port)
        return jsonify({"success": True, "message": "UDP configuration updated"})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/plc/connect", methods=["POST"])
def connect_plc():
    """Connect to PLC"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    if streamer.connect_plc():
        return jsonify({"success": True, "message": "Connected to PLC"})
    else:
        return jsonify({"success": False, "message": "Error connecting to PLC"}), 500


@app.route("/api/plc/disconnect", methods=["POST"])
def disconnect_plc():
    """Disconnect from PLC"""
    streamer.stop_streaming()
    streamer.disconnect_plc()
    return jsonify({"success": True, "message": "Disconnected from PLC"})


@app.route("/api/variables", methods=["POST"])
def add_variable():
    """Add a new variable"""
    try:
        data = request.get_json()
        name = data.get("name")
        area = data.get("area")
        db = int(data.get("db"))
        offset = int(data.get("offset"))
        var_type = data.get("type")
        bit = data.get("bit")  # Added bit parameter

        valid_types = [
            "real",
            "int",
            "bool",
            "dint",
            "word",
            "byte",
            "uint",
            "udint",
            "sint",
            "usint",
        ]
        valid_areas = ["db", "mw", "m", "pew", "pe", "paw", "pa", "e", "a", "mb"]

        if (
            not name
            or not area
            or var_type not in valid_types
            or area.lower() not in valid_areas
        ):
            return jsonify({"success": False, "message": "Invalid data"}), 400

        if area.lower() in ["e", "a", "mb"] and bit is None:
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Bit position must be specified for bit areas",
                    }
                ),
                400,
            )

        if area.lower() in ["e", "a", "mb"] and (bit < 0 or bit > 7):
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Bit position must be between 0 and 7",
                    }
                ),
                400,
            )

        streamer.add_variable(name, area, db, offset, var_type, bit)
        return jsonify({"success": True, "message": f"Variable {name} added"})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/variables/<name>", methods=["DELETE"])
def remove_variable(name):
    """Remove a variable"""
    streamer.remove_variable(name)
    return jsonify({"success": True, "message": f"Variable {name} removed"})


@app.route("/api/variables/<name>", methods=["GET"])
def get_variable(name):
    """Get a specific variable configuration from current dataset"""
    try:
        if not streamer.current_dataset_id:
            return (
                jsonify({"success": False, "message": "No dataset selected"}),
                400,
            )

        current_variables = streamer.get_dataset_variables(streamer.current_dataset_id)
        if name not in current_variables:
            return (
                jsonify({"success": False, "message": f"Variable {name} not found"}),
                404,
            )

        var_config = current_variables[name].copy()
        var_config["name"] = name

        # Check if variable is in streaming list for current dataset
        streaming_vars = streamer.datasets[streamer.current_dataset_id].get(
            "streaming_variables", []
        )
        var_config["streaming"] = name in streaming_vars

        return jsonify({"success": True, "variable": var_config})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/variables/<name>", methods=["PUT"])
def update_variable(name):
    """Update an existing variable in current dataset"""
    try:
        if not streamer.current_dataset_id:
            return jsonify({"success": False, "message": "No dataset selected"}), 400

        data = request.get_json()
        new_name = data.get("name", name)
        area = data.get("area")
        db = int(data.get("db", 1))
        offset = int(data.get("offset"))
        var_type = data.get("type")
        bit = data.get("bit")

        valid_types = [
            "real",
            "int",
            "bool",
            "dint",
            "word",
            "byte",
            "uint",
            "udint",
            "sint",
            "usint",
        ]
        valid_areas = ["db", "mw", "m", "pew", "pe", "paw", "pa", "e", "a", "mb"]

        if (
            not new_name
            or not area
            or var_type not in valid_types
            or area.lower() not in valid_areas
        ):
            return jsonify({"success": False, "message": "Invalid data"}), 400

        if area.lower() in ["e", "a", "mb"] and bit is None:
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Bit position must be specified for bit areas",
                    }
                ),
                400,
            )

        if area.lower() in ["e", "a", "mb"] and (bit < 0 or bit > 7):
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Bit position must be between 0 and 7",
                    }
                ),
                400,
            )

        current_dataset_id = streamer.current_dataset_id
        current_variables = streamer.get_dataset_variables(current_dataset_id)

        # Check if variable exists in current dataset
        if name not in current_variables:
            return (
                jsonify({"success": False, "message": f"Variable {name} not found"}),
                404,
            )

        # Check if new name already exists (if name is changing)
        if name != new_name and new_name in current_variables:
            return (
                jsonify(
                    {
                        "success": False,
                        "message": f"Variable {new_name} already exists",
                    }
                ),
                400,
            )

        # Preserve streaming state
        streaming_vars = streamer.datasets[current_dataset_id].get(
            "streaming_variables", []
        )
        was_streaming = name in streaming_vars

        # Remove old variable
        streamer.remove_variable_from_dataset(current_dataset_id, name)

        # Add updated variable
        streamer.add_variable_to_dataset(
            current_dataset_id, new_name, area, db, offset, var_type, bit, was_streaming
        )

        return jsonify({"success": True, "message": f"Variable updated successfully"})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/variables/<name>/streaming", methods=["POST"])
def toggle_variable_streaming(name):
    """Toggle streaming for a specific variable in current dataset"""
    try:
        if not streamer.current_dataset_id:
            return jsonify({"success": False, "message": "No dataset selected"}), 400

        data = request.get_json()
        enabled = data.get("enabled", False)

        # Use the new dataset-specific method
        streamer.toggle_variable_streaming(streamer.current_dataset_id, name, enabled)

        status = "enabled" if enabled else "disabled"
        return jsonify(
            {"success": True, "message": f"Variable {name} streaming {status}"}
        )

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/variables/streaming", methods=["GET"])
def get_streaming_variables():
    """Get list of variables enabled for streaming in current dataset"""
    if streamer is None:
        return jsonify({"success": False, "error": "Streamer not initialized"}), 503

    # Get streaming variables from current dataset
    streaming_vars = []
    if streamer.current_dataset_id and streamer.current_dataset_id in streamer.datasets:
        streaming_vars = streamer.datasets[streamer.current_dataset_id].get(
            "streaming_variables", []
        )

    return jsonify({"success": True, "streaming_variables": streaming_vars})


# Dataset Management API Endpoints


@app.route("/api/datasets", methods=["GET"])
def get_datasets():
    """Get all datasets"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    return jsonify(
        {
            "success": True,
            "datasets": streamer.datasets,
            "active_datasets": list(streamer.active_datasets),
            "current_dataset_id": streamer.current_dataset_id,
        }
    )


@app.route("/api/datasets", methods=["POST"])
def create_dataset():
    """Create a new dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        data = request.get_json()
        dataset_id = data.get("dataset_id", "").strip()
        name = data.get("name", "").strip()
        prefix = data.get("prefix", "").strip()
        sampling_interval = data.get("sampling_interval")

        if not dataset_id or not name or not prefix:
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Dataset ID, name, and prefix are required",
                    }
                ),
                400,
            )

        # Validate sampling interval if provided
        if sampling_interval is not None:
            sampling_interval = float(sampling_interval)
            if sampling_interval < 0.01:
                return (
                    jsonify(
                        {
                            "success": False,
                            "message": "Sampling interval must be at least 0.01 seconds",
                        }
                    ),
                    400,
                )

        streamer.create_dataset(dataset_id, name, prefix, sampling_interval)

        return jsonify(
            {
                "success": True,
                "message": f"Dataset '{name}' created successfully",
                "dataset_id": dataset_id,
            }
        )

    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 400
    except Exception as e:
        return (
            jsonify({"success": False, "message": f"Error creating dataset: {str(e)}"}),
            500,
        )


@app.route("/api/datasets/<dataset_id>", methods=["DELETE"])
def delete_dataset(dataset_id):
    """Delete a dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        streamer.delete_dataset(dataset_id)
        return jsonify({"success": True, "message": "Dataset deleted successfully"})
    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 404
    except Exception as e:
        return (
            jsonify({"success": False, "message": f"Error deleting dataset: {str(e)}"}),
            500,
        )


@app.route("/api/datasets/<dataset_id>/activate", methods=["POST"])
def activate_dataset(dataset_id):
    """Activate a dataset for streaming"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        streamer.activate_dataset(dataset_id)
        return jsonify({"success": True, "message": "Dataset activated successfully"})
    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 404
    except RuntimeError as e:
        return jsonify({"success": False, "message": str(e)}), 400
    except Exception as e:
        return (
            jsonify(
                {"success": False, "message": f"Error activating dataset: {str(e)}"}
            ),
            500,
        )


@app.route("/api/datasets/<dataset_id>/deactivate", methods=["POST"])
def deactivate_dataset(dataset_id):
    """Deactivate a dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        streamer.deactivate_dataset(dataset_id)
        return jsonify({"success": True, "message": "Dataset deactivated successfully"})
    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 404
    except Exception as e:
        return (
            jsonify(
                {"success": False, "message": f"Error deactivating dataset: {str(e)}"}
            ),
            500,
        )


@app.route("/api/datasets/<dataset_id>/variables", methods=["POST"])
def add_variable_to_dataset(dataset_id):
    """Add a variable to a dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        data = request.get_json()
        name = data.get("name", "").strip()
        area = data.get("area", "").strip()
        db = data.get("db", 1)
        offset = data.get("offset", 0)
        var_type = data.get("type", "").strip()
        bit = data.get("bit")
        streaming = data.get("streaming", False)

        if not name or not area or not var_type:
            return (
                jsonify(
                    {
                        "success": False,
                        "message": "Variable name, area, and type are required",
                    }
                ),
                400,
            )

        streamer.add_variable_to_dataset(
            dataset_id, name, area, db, offset, var_type, bit, streaming
        )

        return jsonify(
            {
                "success": True,
                "message": f"Variable '{name}' added to dataset successfully",
            }
        )

    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 400
    except Exception as e:
        return (
            jsonify({"success": False, "message": f"Error adding variable: {str(e)}"}),
            500,
        )


@app.route("/api/datasets/<dataset_id>/variables/<variable_name>", methods=["DELETE"])
def remove_variable_from_dataset(dataset_id, variable_name):
    """Remove a variable from a dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        streamer.remove_variable_from_dataset(dataset_id, variable_name)
        return jsonify(
            {
                "success": True,
                "message": f"Variable '{variable_name}' removed from dataset successfully",
            }
        )
    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 404
    except Exception as e:
        return (
            jsonify(
                {"success": False, "message": f"Error removing variable: {str(e)}"}
            ),
            500,
        )


@app.route(
    "/api/datasets/<dataset_id>/variables/<variable_name>/streaming", methods=["POST"]
)
def toggle_variable_streaming_in_dataset(dataset_id, variable_name):
    """Toggle streaming for a variable in a dataset"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        data = request.get_json()
        enabled = data.get("enabled", False)

        streamer.toggle_variable_streaming(dataset_id, variable_name, enabled)

        return jsonify(
            {
                "success": True,
                "message": f"Variable '{variable_name}' streaming {'enabled' if enabled else 'disabled'}",
            }
        )
    except ValueError as e:
        return jsonify({"success": False, "message": str(e)}), 404
    except Exception as e:
        return (
            jsonify(
                {"success": False, "message": f"Error toggling streaming: {str(e)}"}
            ),
            500,
        )


@app.route("/api/datasets/current", methods=["POST"])
def set_current_dataset():
    """Set the current dataset for editing"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        data = request.get_json()
        dataset_id = data.get("dataset_id")

        if dataset_id and dataset_id in streamer.datasets:
            streamer.current_dataset_id = dataset_id
            streamer.save_datasets()
            return jsonify(
                {
                    "success": True,
                    "message": "Current dataset updated successfully",
                    "current_dataset_id": dataset_id,
                }
            )
        else:
            return jsonify({"success": False, "message": "Invalid dataset ID"}), 400

    except Exception as e:
        return (
            jsonify(
                {
                    "success": False,
                    "message": f"Error setting current dataset: {str(e)}",
                }
            ),
            500,
        )


@app.route("/api/streaming/start", methods=["POST"])
def start_streaming():
    """Start streaming"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    if streamer.start_streaming():
        return jsonify({"success": True, "message": "Streaming started"})
    else:
        return jsonify({"success": False, "message": "Error starting streaming"}), 500


@app.route("/api/streaming/stop", methods=["POST"])
def stop_streaming():
    """Stop streaming"""
    streamer.stop_streaming()
    return jsonify({"success": True, "message": "Streaming stopped"})


@app.route("/api/sampling", methods=["POST"])
def update_sampling():
    """Update sampling interval"""
    try:
        data = request.get_json()
        interval = float(data.get("interval", 0.1))

        if interval < 0.01:
            interval = 0.01

        streamer.update_sampling_interval(interval)
        return jsonify({"success": True, "message": f"Interval updated to {interval}s"})

    except Exception as e:
        return jsonify({"success": False, "message": str(e)}), 400


@app.route("/api/csv/start", methods=["POST"])
def start_csv_recording():
    """Start CSV recording independently"""
    if streamer.start_csv_recording():
        return jsonify({"success": True, "message": "CSV recording started"})
    else:
        return (
            jsonify({"success": False, "message": "Error starting CSV recording"}),
            500,
        )


@app.route("/api/csv/stop", methods=["POST"])
def stop_csv_recording():
    """Stop CSV recording independently"""
    streamer.stop_csv_recording()
    return jsonify({"success": True, "message": "CSV recording stopped"})


@app.route("/api/status")
def get_status():
    """Get current status"""
    if streamer is None:
        return jsonify({"error": "Application not initialized"}), 503
    return jsonify(streamer.get_status())


@app.route("/api/events")
def get_events():
    """Get recent events from the application log"""
    error_response = check_streamer_initialized()
    if error_response:
        return error_response

    try:
        limit = request.args.get("limit", 50, type=int)
        limit = min(limit, 200)  # Maximum 200 events per request

        events = streamer.get_recent_events(limit)
        return jsonify(
            {
                "success": True,
                "events": events,
                "total_events": len(streamer.events_log),
                "showing": len(events),
            }
        )
    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500


def graceful_shutdown():
    """Perform graceful shutdown"""
    print("\n⏹️  Performing graceful shutdown...")
    try:
        streamer.stop_streaming()
        streamer.disconnect_plc()
        streamer.release_instance_lock()
        print("✅ Shutdown completed successfully")
    except Exception as e:
        print(f"⚠️  Error during shutdown: {e}")


def main():
    """Main application entry point with error handling and recovery"""
    max_retries = 3
    retry_count = 0

    while retry_count < max_retries:
        try:
            # Create templates directory if it doesn't exist
            os.makedirs("templates", exist_ok=True)

            print("🚀 Starting Flask server for PLC S7-315 Streamer")
            print("📊 Web interface available at: http://localhost:5050")
            print("🔧 Configure your PLC and variables through the web interface")

            # Initialize streamer (this will handle instance locking and auto-recovery)
            global streamer

            # Start Flask application
            app.run(debug=False, host="0.0.0.0", port=5050, use_reloader=False)

            # If we reach here, the server stopped normally
            break

        except RuntimeError as e:
            if "Another instance" in str(e):
                print(f"❌ {e}")
                print("💡 Tip: Stop the other instance or wait for it to finish")
                sys.exit(1)
            else:
                print(f"⚠️  Runtime error: {e}")
                retry_count += 1

        except KeyboardInterrupt:
            print("\n⏸️  Received interrupt signal...")
            graceful_shutdown()
            break

        except Exception as e:
            print(f"💥 Unexpected error: {e}")
            retry_count += 1

            if retry_count < max_retries:
                print(f"🔄 Attempting restart ({retry_count}/{max_retries})...")
                time.sleep(2)  # Wait before retry
            else:
                print("❌ Maximum retries reached. Exiting...")
                graceful_shutdown()
                sys.exit(1)


if __name__ == "__main__":
    try:
        # Initialize streamer instance
        streamer = PLCDataStreamer()
        main()
    except Exception as e:
        print(f"💥 Critical error during initialization: {e}")
        sys.exit(1)