app.py

from flask import Flask, jsonify, request
import firebase_admin
from firebase_admin import credentials, firestore, db
from datetime import datetime
import socket
import threading
import json
import warnings
import time
import logging
from concurrent.futures import ThreadPoolExecutor
from flask_cors import CORS
from functools import wraps

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.FileHandler("server.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

# Suppress specific warning
warnings.filterwarnings("ignore", message="Detected filter using positional arguments. Prefer using the 'filter' keyword argument instead.")

app = Flask(__name__)
executor = ThreadPoolExecutor(max_workers=5)

# Configure CORS
CORS(app, resources={
    r"/*": {
        "origins": "*",
        "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
        "allow_headers": ["Content-Type", "Authorization"]
    }
})

# Initialize Firebase
try:
    firebase_admin.initialize_app(
        credentials.Certificate("./perimeter-ffe11-firebase-adminsdk-jirwr-9398fc7638.json"),
        {'databaseURL': 'https://perimeter-ffe11-default-rtdb.asia-southeast1.firebasedatabase.app/'}
    )
    db_firestore = firestore.client()
    realtime_db = db.reference()
    logger.info("Firebase initialized successfully")
except Exception as e:
    logger.error(f"Firebase initialization error: {e}")
    raise

# Global variables with thread-safe access
class SharedState:
    def __init__(self):
        self.lock = threading.RLock()
        self.client_socket = None
        self.gate = None
        self.pending_request = None
        self.message_received = False
        self.last_rfid_scan_time = 0
        self.cooldown_period = 3  # seconds - added cooldown to prevent duplicate scans
        self.last_gate_open_time = 0
        self.gate_open_cooldown = 5  # seconds - increased to prevent double gate openings
        self.processing_rfid = False
        self.gate_open_in_progress = False  # Flag to track if gate opening is in progress

state = SharedState()

# Query documents from Firestore
def query_documents(collection_name, filters=None):
    try:
        query = db_firestore.collection(collection_name)
        if filters:
            for field, op, value in filters:
                query = query.where(field, op, value)
        
        results = []
        for doc in query.stream():
            doc_dict = doc.to_dict()
            doc_dict['id'] = doc.id
            results.append(doc_dict)
        
        logger.debug(f"Query results from {collection_name}: {len(results)} documents found")
        return results
    except Exception as e:
        logger.error(f"Error querying documents from {collection_name}: {e}")
        return []

# Direct add entry to realtime database
def add_entry_to_realtime_db(data):
    try:
        ref = realtime_db.child('gateWayLog')
        new_entry = ref.push(data)
        logger.info(f"Added entry to Realtime DB successfully with key: {new_entry.key}")
        return {'success': True, 'key': new_entry.key}
    except Exception as e:
        logger.error(f"Error adding to Realtime DB: {e}")
        return {'success': False, 'error': str(e)}

# Get all entries from gateWayLog
def get_all_gateway_logs():
    try:
        logs = realtime_db.child('gateWayLog').get()
        return logs or {}
    except Exception as e:
        logger.error(f"Error getting gateway logs: {e}")
        return {}

# Find entries by matching field in realtime DB
def find_entries_by_field(field_name, field_value):
    try:
        all_logs = get_all_gateway_logs()
        matching_entries = {}
        
        for key, entry in all_logs.items():
            if entry.get(field_name) == field_value:
                matching_entries[key] = entry
                
        logger.info(f"Found {len(matching_entries)} entries with {field_name}={field_value}")
        return matching_entries
    except Exception as e:
        logger.error(f"Error finding entries by field: {e}")
        return {}

# Updated log gateway entry function
def log_gateway_entry(rfid):
    try:
        current_time = datetime.now().isoformat()

        # Check if the RFID exists in Firestore
        rfid_docs = query_documents('RFID_Req', [('rfid', '==', rfid), ('status', '==', 'issued')])
        if not rfid_docs:
            log_data = {
                'rfid': rfid,
                'name': 'Unknown',
                'roomNo': None,
                'timeIn': current_time,
                'timeOut': None,
                'status': 'Denied',
                'type': 'Rfid'
            }
            result = add_entry_to_realtime_db(log_data)
            logger.info(f"Access denied log created: {log_data}")
            return {'message': 'Access denied: RFID not found or not issued', 'success': result['success']}

        room_no = rfid_docs[0].get('roomNo')
        name = rfid_docs[0].get('name')

        # Check for existing logs with no timeOut
        existing_entries = find_entries_by_field('rfid', rfid)
        
        # Check for open entries (no timeOut)
        for key, entry in existing_entries.items():
            if entry.get('timeOut') is None:
                try:
                    realtime_db.child('gateWayLog').child(key).update({
                        'timeOut': current_time, 
                        'status': 'OUT'
                    })
                    logger.info(f"TimeOut updated for RFID {rfid}, key: {key}")
                    return {'message': 'TimeOut updated and status set to OUT', 'success': True}
                except Exception as e:
                    logger.error(f"Error updating timeOut: {e}")
                    # Continue to create new entry as fallback
        
        # Create a new log entry with status "IN"
        log_data = {
            'rfid': rfid,
            'name': name,
            'roomNo': room_no,
            'timeIn': current_time,
            'timeOut': None,
            'status': 'IN',
            'type': 'Rfid'
        }
        result = add_entry_to_realtime_db(log_data)
        logger.info(f"New log created for RFID {rfid}")
        return {'message': 'New log created with status IN', 'success': result['success']}

    except Exception as e:
        logger.error(f"Error in log_gateway_entry: {e}")
        return {'error': str(e), 'success': False}

# Process pending RFID request with anti-duplicate protection
def process_pending_request(rid):
    with state.lock:
        if not state.message_received:
            return {'gate': None, 'success': False}
            
        if state.processing_rfid:
            logger.info("Already processing an RFID request, ignoring duplicate")
            return {'gate': None, 'message': 'Already processing request', 'success': False}
            
        current_time = time.time()
        
        # Add cooldown check to prevent rapid consecutive RFID scans
        if current_time - state.last_rfid_scan_time < state.cooldown_period:
            logger.info(f"RFID scan rejected - too soon after last scan ({current_time - state.last_rfid_scan_time:.2f}s)")
            return {'gate': None, 'message': 'Please wait before scanning again', 'success': False}
        
        state.last_rfid_scan_time = current_time
        state.processing_rfid = True
    
    try:
        # Process the RFID request
        docs = query_documents('RFID_Req', [('status', '==', 'issued'), ('rfid', '==', rid)])
        gate_access = bool(docs)
        log_result = log_gateway_entry(rid)
        
        response = {
            'gate': gate_access, 
            'logResult': log_result,
            'success': log_result.get('success', False)
        }
        
        # Only send gate open signal if access is granted and cooldown passed
        if gate_access:
            with state.lock:
                current_time = time.time()
                if current_time - state.last_gate_open_time >= state.gate_open_cooldown and not state.gate_open_in_progress:
                    state.last_gate_open_time = current_time
                    state.gate_open_in_progress = True  # Set the flag before starting execution
                    executor.submit(push_gate_open_message)
                else:
                    logger.info(f"Gate open signal suppressed (cooldown active: {current_time - state.last_gate_open_time:.2f}s)")
        
        return response
    except Exception as e:
        logger.error(f"Error in process_pending_request: {e}")
        return {'gate': None, 'error': str(e), 'success': False}
    finally:
        with state.lock:
            state.message_received = False
            state.processing_rfid = False

def send_to_esp32(message):
    with state.lock:
        client_socket = state.client_socket
    
    if not client_socket:
        logger.warning("No active client connection to send the message.")
        return False
        
    try:
        message_json = json.dumps(message)
        client_socket.sendall(message_json.encode())
        logger.info(f"Message sent to ESP32: {message}")
        return True
    except Exception as e:
        logger.error(f"Error sending message to ESP32: {e}")
        return False

def push_gate_open_message():
    try:
        message = {"gate": True}
        success = send_to_esp32(message)
        if success:
            logger.info("Gate open signal sent successfully")
        else:
            logger.warning("Failed to send gate open signal")
    finally:
        # Reset the gate open in progress flag when complete
        with state.lock:
            state.gate_open_in_progress = False

# Handle client connections
def handle_client_connection(conn, addr):
    logger.info(f"Connected by {addr}")
    
    with state.lock:
        state.client_socket = conn
    
    try:
        conn.settimeout(300)  # 5-minute timeout
        buffer = ""
        
        while True:
            try:
                data = conn.recv(1024)
                if not data:
                    logger.info(f"Connection closed by {addr}")
                    break

                buffer += data.decode()
                
                # Process complete JSON objects
                while buffer.find('}') != -1:
                    try:
                        end_pos = buffer.find('}') + 1
                        json_str = buffer[:end_pos]
                        buffer = buffer[end_pos:]
                        
                        json_data = json.loads(json_str)
                        process_client_message(conn, json_data)
                    except json.JSONDecodeError:
                        # Incomplete or invalid JSON, wait for more data
                        break
                    except Exception as e:
                        logger.error(f"Error processing message: {e}")
                        conn.sendall(json.dumps({"error": str(e)}).encode())
                        
            except socket.timeout:
                logger.info(f"Connection from {addr} timed out")
                break
            except ConnectionResetError:
                logger.info(f"Connection reset by {addr}")
                break
            except Exception as e:
                logger.error(f"Connection error with {addr}: {e}")
                break
                
    finally:
        with state.lock:
            if state.client_socket == conn:
                state.client_socket = None
        conn.close()
        logger.info(f"Connection with {addr} closed")

def process_client_message(conn, json_data):
    mode = json_data.get('mode')
    rid = json_data.get('rfid')
    
    logger.info(f"Processing message: mode={mode}, rfid={rid}")
    
    if mode not in ['read', 'write', 'written']:
        conn.sendall(json.dumps({"error": 'Invalid mode parameter'}).encode())
        logger.warning(f"Invalid mode: {mode}")
        return

    try:
        if mode == 'read':
            with state.lock:
                if not rid:
                    state.pending_request = {'mode': 'read'}
                    conn.sendall(json.dumps({"message": "Waiting for RFID"}).encode())
                    return

                state.message_received = True
                
            response = process_pending_request(rid)
            conn.sendall(json.dumps(response).encode())
            logger.info(f"Response sent for RFID read: {response}")

        elif mode == 'write':
            docs = query_documents('RFID_Req', [('status', '==', 'writing')])
            filtered_docs = [{'name': doc.get('name'), 'roomNo': doc.get('roomNo'), 'rfid': doc.get('rfid')} for doc in docs]
            response = {"documents": filtered_docs} if docs else {"error": "No documents found"}
            conn.sendall(json.dumps(response).encode())
            logger.info(f"Response sent for RFID write: {len(filtered_docs)} documents")

        elif mode == 'written':
            docs = query_documents('RFID_Req', [('status', '==', 'writing')])
            if not docs:
                conn.sendall(json.dumps({"error": "No document to update"}).encode())
                return

            doc_id, user_id = docs[0]['id'], docs[0].get('userId')
            
            # Update document status
            db_firestore.collection('RFID_Req').document(doc_id).update({"status": "issued"})
            logger.info(f"Document {doc_id} updated to 'issued' status")

            # Update user RFID count if applicable
            if user_id:
                user_query = db_firestore.collection('users').where('uid', '==', user_id).limit(1)
                user_doc = next(user_query.stream(), None)
                if user_doc:
                    user_doc.reference.update({"rfidCount": firestore.Increment(1)})
                    logger.info(f"User {user_id} RFID count incremented")

            conn.sendall(json.dumps({"message": "Document updated successfully"}).encode())
            
    except Exception as e:
        error_msg = {"error": str(e)}
        conn.sendall(json.dumps(error_msg).encode())
        logger.error(f"Error processing client message: {e}")

# Log face recognition entry
def log_face_recognition_entry(name):
    try:
        current_time = datetime.now().isoformat()

        # Find existing logs with no timeOut
        existing_entries = find_entries_by_field('name', name)
        
        for key, entry in existing_entries.items():
            if entry.get('timeOut') is None:
                try:
                    realtime_db.child('gateWayLog').child(key).update({
                        'timeOut': current_time, 
                        'status': 'OUT'
                    })
                    logger.info(f"TimeOut updated for face recognition: {name}, key: {key}")
                    return {'message': 'TimeOut updated and status set to OUT', 'success': True}
                except Exception as e:
                    logger.error(f"Error updating timeOut for face: {e}")
                    # Continue to create new entry as fallback

        # Create a new log entry with status "IN"
        log_data = {
            'rfid': None,
            'name': name,
            'roomNo': None,
            'timeIn': current_time,
            'timeOut': None,
            'status': 'IN',
            'type': 'Face'
        }
        result = add_entry_to_realtime_db(log_data)
        logger.info(f"New face recognition log created: {name}")
        return {'message': 'New face recognition log created with status IN', 'success': result['success']}

    except Exception as e:
        logger.error(f"Error in log_face_recognition_entry: {e}")
        return {'error': str(e), 'success': False}

# Enhanced visitor entry logic
def log_visitor_entry(visitor_data):
    try:
        current_time = datetime.now().isoformat()
        status = visitor_data.get('status', 'entry')
        status_mapping = {
            'entry': 'IN',
            'exit': 'OUT'
        }
        formatted_status = status_mapping.get(status.lower(), status.upper())
        
        # Get visitor details from either collection based on roomNo
        room_no = visitor_data.get('roomNo')
        block = visitor_data.get('block')
        visitor_name = visitor_data.get('role', 'Visitor')
        phone = visitor_data.get('phone')
        
        # Look for visitor data in preauthorize collection first
        visitor_docs = query_documents('preauthorize', [('roomNo', '==', room_no), ('block', '==', block)])
        
        # If not found, try the request collection
        if not visitor_docs:
            visitor_docs = query_documents('request', [('roomNo', '==', room_no), ('block', '==', block)])
        
        # Get visitor details if available
        if visitor_docs:
            visitor_name = visitor_docs[0].get('name', visitor_name)
            phone = visitor_docs[0].get('phone', phone)
        
        log_data = {
            'rfid': None,
            'name': visitor_name,
            'roomNo': room_no,
            'block': block,
            'phone': phone,
            'timeIn': current_time if formatted_status == 'IN' else None,
            'timeOut': current_time if formatted_status == 'OUT' else None,
            'status': formatted_status,
            'type': 'Visitor'
        }
        
        # For OUT status, try to find and update existing entry
        if formatted_status == 'OUT':
            existing_entries = find_entries_by_field('roomNo', room_no)
            for key, entry in existing_entries.items():
                if entry.get('timeOut') is None and entry.get('block') == block:
                    try:
                        realtime_db.child('gateWayLog').child(key).update({
                            'timeOut': current_time, 
                            'status': 'OUT'
                        })
                        logger.info(f"TimeOut updated for visitor: {entry.get('name')}, room: {room_no}, key: {key}")
                        return {'message': 'TimeOut updated and status set to OUT', 'success': True}
                    except Exception as e:
                        logger.error(f"Error updating timeOut for visitor: {e}")
                        # Continue to create new entry as fallback
        
        result = add_entry_to_realtime_db(log_data)
        logger.info(f"New visitor log created: {log_data}")
        return {'message': f'New visitor log created with status {formatted_status}', 'success': result['success']}
    
    except Exception as e:
        logger.error(f"Error in log_visitor_entry: {e}")
        return {'error': str(e), 'success': False}

# Flask route for face recognition
@app.route('/face_recognition', methods=['POST'])
def handle_face_recognition():
    try:
        data = request.json
        logger.info(f"Face recognition request: {data}")
        
        name = data.get('recognized_person')
        
        if not name:
            return jsonify({'error': 'No name provided'}), 400

        # Log the face recognition entry
        log_result = log_face_recognition_entry(name)
        
        # Check gate cooldown before opening
        open_gate = False
        with state.lock:
            current_time = time.time()
            if current_time - state.last_gate_open_time >= state.gate_open_cooldown and not state.gate_open_in_progress:
                state.last_gate_open_time = current_time
                state.gate_open_in_progress = True
                open_gate = True
        
        # Trigger gate opening if cooldown passed
        if open_gate:
            executor.submit(push_gate_open_message)
            gate_message = "Gate open signal sent"
        else:
            gate_message = "Gate open suppressed (cooldown active)"
        
        response = {
            'message': 'Face recognition processed successfully',
            'name': name,
            'log_result': log_result,
            'gate': gate_message
        }
        
        logger.info(f"Face recognition response: {response}")
        return jsonify(response), 200

    except Exception as e:
        logger.error(f"Error in handle_face_recognition: {e}")
        return jsonify({'error': str(e)}), 500

# Flask route for status handling with improved visitor data functionality
@app.route('/status', methods=['POST', 'OPTIONS'])
def handle_status():
    # Handle preflight request
    if request.method == 'OPTIONS':
        response = app.make_default_options_response()
        return response

    try:
        data = request.json
        logger.info(f"Status request received: {data}")
        
        if not data or 'status' not in data:
            logger.warning("Invalid request data")
            return jsonify({'error': 'Invalid request data'}), 400

        status = data.get('status')
        room_no = data.get('roomNo')
        block = data.get('block')
        
        # Validate required fields
        if not room_no or not block:
            logger.warning("Missing required fields (roomNo or block)")
            return jsonify({'error': 'Missing required fields'}), 400
        
        # Check gate cooldown before opening
        open_gate = False
        with state.lock:
            current_time = time.time()
            if current_time - state.last_gate_open_time >= state.gate_open_cooldown and not state.gate_open_in_progress:
                state.last_gate_open_time = current_time
                state.gate_open_in_progress = True
                open_gate = True
        
        # Send gate open signal if cooldown passed
        if status in ['entry', 'exit'] and open_gate:
            logger.info("Attempting to open gate...")
            executor.submit(push_gate_open_message)
            gate_message = "Gate open signal queued"
        else:
            gate_message = "Gate open suppressed (cooldown active or invalid status)"

        # Log the entry/exit with enhanced visitor data
        log_result = log_visitor_entry({
            'block': block,
            'roomNo': room_no,
            'role': data.get('role'),
            'phone': data.get('phone'),
            'status': status 
        })
        
        response = {
            'message': f'Status {status} processed successfully',
            'log_result': log_result,
            'gate': gate_message
        }
        
        logger.info(f"Status response: {response}")
        return jsonify(response), 200

    except Exception as e:
        logger.error(f"Error in handle_status: {e}")
        return jsonify({'error': str(e)}), 500

# Health check endpoint
@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({
        'status': 'healthy',
        'time': datetime.now().isoformat(),
        'firebase_connected': bool(db_firestore and realtime_db),
        'socket_client_connected': bool(state.client_socket),
        'gate_status': {
            'last_open': datetime.fromtimestamp(state.last_gate_open_time).isoformat() if state.last_gate_open_time > 0 else None,
            'open_in_progress': state.gate_open_in_progress,
            'cooldown': state.gate_open_cooldown
        }
    })

# Test endpoint for firebase connection
@app.route('/test_firebase', methods=['GET'])
def test_firebase():
    try:
        # Test write to Realtime DB
        test_ref = realtime_db.child('test')
        test_data = {
            'timestamp': datetime.now().isoformat(),
            'message': 'Firebase connection test'
        }
        result = test_ref.push(test_data)
        
        return jsonify({
            'status': 'success',
            'message': 'Firebase write successful',
            'key': result.key
        })
    except Exception as e:
        return jsonify({
            'status': 'error',
            'message': str(e)
        }), 500

# Endpoint to test collections and queries
@app.route('/test_collections', methods=['GET'])
def test_collections():
    try:
        collection = request.args.get('collection', 'request')
        room_no = request.args.get('roomNo')
        block = request.args.get('block')
        
        filters = []
        if room_no:
            filters.append(('roomNo', '==', room_no))
        if block:
            filters.append(('block', '==', block))
            
        results = query_documents(collection, filters)
        
        return jsonify({
            'status': 'success',
            'collection': collection,
            'filters': {
                'roomNo': room_no,
                'block': block
            },
            'count': len(results),
            'results': results
        })
    except Exception as e:
        return jsonify({
            'status': 'error',
            'message': str(e)
        }), 500

def run_flask():
    app.run(host='0.0.0.0', port=5001, threaded=True)

# Server startup function
def start_server():
    try:
        # Set initial configuration
        state.cooldown_period = 3  # seconds
        state.gate_open_cooldown = 5  # seconds
        
        # Start Flask server in a separate thread
        flask_thread = threading.Thread(target=run_flask, daemon=True, name="FlaskThread")
        flask_thread.start()
        logger.info("Flask server started on 0.0.0.0:5001")

        # Start socket server
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        server_socket.bind(('0.0.0.0', 5000))
        server_socket.listen(5)  # Allow 5 backlog connections
        logger.info("Socket server running on 0.0.0.0:5000...")
        
        # Main server loop
        while True:
            try:
                conn, addr = server_socket.accept()
                client_thread = threading.Thread(
                    target=handle_client_connection, 
                    args=(conn, addr),
                    daemon=True,
                    name=f"Client-{addr[0]}:{addr[1]}"
                )
                client_thread.start()
            except KeyboardInterrupt:
                logger.info("Server shutdown requested...")
                break
            except Exception as e:
                logger.error(f"Error accepting connection: {e}")
                time.sleep(1)  # Prevent CPU hogging on repeated errors
                
    except Exception as e:
        logger.critical(f"Critical server error: {e}")
        raise
    finally:
        logger.info("Server shutting down...")
        try:
            server_socket.close()
        except:
            pass

if __name__ == '__main__':
    try:
        logger.info("Starting server...")
        start_server()
    except KeyboardInterrupt:
        logger.info("Server terminated by user")
    except Exception as e:
        logger.critical(f"Fatal error: {e}")
        raise