app.py

from flask import Flask, request, jsonify
import mysql.connector
from flask_cors import CORS
from datetime import date 

# --- 1. CONFIGURATION ---

DB_CONFIG = {
    'user': 'root',
    'password': '#aleesha123',  
    'host': '127.0.0.1',
    'database': 'hospital_db',    
}

# IMPORTANT: Flask serves index.html, admin.html, and styles.css from the 'static' folder
app = Flask(__name__, static_folder='static') 
CORS(app) 

# --- 2. DATABASE UTILITY FUNCTION ---

def get_db_connection():
    """Establishes and returns a connection to the MySQL database."""
    try:
        conn = mysql.connector.connect(**DB_CONFIG)
        return conn
    except mysql.connector.Error as err:
        print(f"Error connecting to MySQL: {err}") 
        return None

# --- 3. HTML PAGE ROUTES ---

@app.route('/', methods=['GET'])
def serve_index_page():
    """Serves the main Patient Login/Dashboard page."""
    return app.send_static_file('index.html')

@app.route('/admin', methods=['GET'])
def serve_admin_page():
    """Serves the dedicated Admin Data Entry page."""
    return app.send_static_file('admin.html')


# --- 4. API ENDPOINTS (Authentication, Data Retrieval, Deletion) ---

@app.route('/api/check_user', methods=['POST'])
def check_user_existence():
    """Checks if a user exists for two-step authentication."""
    data = request.json
    name = data.get('name')
    phone = data.get('phone')
    
    if not name or not phone:
        return jsonify({'success': False, 'message': 'Name and phone are required.'}), 400

    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor(dictionary=True)

    try:
        cursor.execute("SELECT P_ID FROM PATIENT WHERE P_Name = %s AND P_Phone = %s", (name, phone))
        patient_record = cursor.fetchone()

        if patient_record:
            return jsonify({'success': True,'is_new': False,'p_id': patient_record['P_ID']})
        else:
            return jsonify({'success': True,'is_new': True})

    except mysql.connector.Error as err:
        print(f"MySQL Error during user check: {err}") 
        return jsonify({'success': False, 'message': f'Database error during check: {err}'}), 500
    finally:
        cursor.close()
        conn.close()


@app.route('/api/register', methods=['POST'])
def handle_registration():
    """Handles the detailed patient signup (INSERT), including optional Doctor/Room/Date."""
    data = request.json
    name = data.get('name')
    phone = data.get('phone')
    address = data.get('address')
    age = data.get('age')
    gender = data.get('gender')
    
    # NEW: Get the optional fields. Convert empty strings to None (NULL)
    # The 'or None' ensures that if the field is empty in the form, it sends NULL to the DB.
    doctor_id = data.get('doctor_id') or None
    room_id = data.get('room_id') or None
    
    # Admission Date: Use input if provided, otherwise use today's date
    input_date = data.get('admission_date')
    admission_date = input_date if input_date else date.today()
    
    # Core validation remains the same
    if not all([name, phone, address, age, gender]):
        return jsonify({'success': False, 'message': 'Core registration fields are required.'}), 400

    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor()

    try:
        insert_query = """
        INSERT INTO PATIENT 
        (P_Name, P_Phone, P_Address, P_Age, P_Gender, Admission_Date, Doctor_ID, Room_ID) 
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
        """
        
        cursor.execute(insert_query, (name, phone, address, age, gender, 
                                      admission_date, doctor_id, room_id))
        conn.commit()
        
        p_id = cursor.lastrowid

        return jsonify({
            'success': True,
            'message': 'Registration successful. Welcome!',
            'p_id': p_id
        })

    except mysql.connector.Error as err:
        conn.rollback()
        print(f"MySQL Error during registration: {err}") 
        return jsonify({'success': False, 'message': f'Database error during registration: {err}'}), 500
    finally:
        cursor.close()
        conn.close()


@app.route('/api/patient_data/<int:p_id>', methods=['GET'])
def get_patient_dashboard_data(p_id):
    """Retrieves all related patient, doctor, room, and treatment data using JOINs."""
    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor(dictionary=True)
    
    try:
        patient_info_query = """
        SELECT
            P.P_ID, P.P_Name, P.P_Age, P.P_Gender, P.Admission_Date, P.P_Address,
            D.D_Name AS Doctor_Name, D.D_Specialization, D.D_Phone AS Doctor_Phone,
            R.Room_ID, R.Allocation_Details
        FROM PATIENT P
        LEFT JOIN DOCTOR D ON P.Doctor_ID = D.Doctor_ID
        LEFT JOIN ROOM R ON P.Room_ID = R.Room_ID
        WHERE P.P_ID = %s
        """
        cursor.execute(patient_info_query, (p_id,))
        patient_data = cursor.fetchone()

        if not patient_data:
            return jsonify({'success': False, 'message': 'Patient not found.'}), 404

        treatment_query = """
        SELECT
            Diagnosis, Treatment_Details, T_Date
        FROM TREATMENT
        WHERE P_ID = %s
        ORDER BY T_Date DESC
        """
        cursor.execute(treatment_query, (p_id,))
        treatment_history = cursor.fetchall()

        response_data = {
            'patient': patient_data,
            'treatments': treatment_history
        }

        return jsonify({'success': True, 'data': response_data})

    except mysql.connector.Error as err:
        print(f"MySQL Error during data retrieval: {err}") 
        return jsonify({'success': False, 'message': f'Database error during data retrieval: {err}'}), 500
    finally:
        cursor.close()
        conn.close()


@app.route('/api/patient/<int:p_id>', methods=['DELETE'])
def delete_patient_record(p_id):
    """Deletes a patient record and associated treatments."""
    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor()

    try:
        conn.start_transaction()

        cursor.execute("DELETE FROM TREATMENT WHERE P_ID = %s", (p_id,))
        cursor.execute("DELETE FROM PATIENT WHERE P_ID = %s", (p_id,))
        
        conn.commit()
        
        if cursor.rowcount == 0:
            return jsonify({'success': False, 'message': 'Patient not found to delete.'}), 404

        return jsonify({'success': True, 'message': f'Patient (ID: {p_id}) and related records deleted.'})

    except mysql.connector.Error as err:
        conn.rollback()
        print(f"MySQL Error during deletion: {err}") 
        return jsonify({'success': False, 'message': f'Database error during deletion: {err}'}), 500
    finally:
        cursor.close()
        conn.close()

# --- 5. ADMIN/DATA ENTRY ENDPOINTS ---

@app.route('/api/add_doctor', methods=['POST'])
def add_doctor_record():
    """Adds a new doctor record to the DOCTOR table."""
    data = request.json
    name = data.get('name')
    phone = data.get('phone')
    email = data.get('email')
    specialization = data.get('specialization')

    if not all([name, specialization]):
        return jsonify({'success': False, 'message': 'Doctor Name and Specialization are required.'}), 400

    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor()
    
    try:
        insert_query = """
        INSERT INTO DOCTOR (D_Name, D_Phone, D_Email, D_Specialization) 
        VALUES (%s, %s, %s, %s)
        """
        cursor.execute(insert_query, (name, phone, email, specialization))
        conn.commit()
        
        return jsonify({'success': True, 'message': f'Doctor {name} added successfully with ID: {cursor.lastrowid}'})

    except mysql.connector.Error as err:
        conn.rollback()
        print(f"MySQL Error during doctor add: {err}")
        return jsonify({'success': False, 'message': f'Database error: {err}'}), 500
    finally:
        cursor.close()
        conn.close()

@app.route('/api/add_room', methods=['POST'])
def add_room_record():
    """Adds a new room record to the ROOM table."""
    data = request.json
    room_id = data.get('id') 
    details = data.get('details')

    if not all([room_id, details]):
        return jsonify({'success': False, 'message': 'Room ID and Allocation Details are required.'}), 400

    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor()
    
    try:
        insert_query = "INSERT INTO ROOM (Room_ID, Allocation_Details) VALUES (%s, %s)"
        cursor.execute(insert_query, (room_id, details))
        conn.commit()
        
        return jsonify({'success': True, 'message': f'Room {room_id} added successfully.'})

    except mysql.connector.Error as err:
        conn.rollback()
        print(f"MySQL Error during room add: {err}")
        return jsonify({'success': False, 'message': f'Database error: {err}'}), 500
    finally:
        cursor.close()
        conn.close()


@app.route('/api/add_treatment', methods=['POST'])
def add_treatment_record():
    """Adds a new treatment record to the TREATMENT table."""
    data = request.json
    p_id = data.get('p_id')
    doctor_id = data.get('doctor_id')
    diagnosis = data.get('diagnosis')
    details = data.get('details')
    t_date = data.get('date') 

    if not all([p_id, doctor_id, diagnosis, t_date]):
        return jsonify({'success': False, 'message': 'Patient ID, Doctor ID, Diagnosis, and Date are required.'}), 400

    conn = get_db_connection()
    if conn is None:
        return jsonify({'success': False, 'message': 'Database connection failed.'}), 500

    cursor = conn.cursor()
    
    try:
        insert_query = """
        INSERT INTO TREATMENT (P_ID, Doctor_ID, Diagnosis, Treatment_Details, T_Date) 
        VALUES (%s, %s, %s, %s, %s)
        """
        cursor.execute(insert_query, (p_id, doctor_id, diagnosis, details, t_date))
        conn.commit()
        
        return jsonify({'success': True, 'message': f'Treatment added for Patient ID {p_id}.'})

    except mysql.connector.Error as err:
        conn.rollback()
        print(f"MySQL Error during treatment add: {err}")
        return jsonify({'success': False, 'message': f'Database error: {err}'}), 500
    finally:
        cursor.close()
        conn.close()


# --- 6. RUN THE FLASK APP ---

if __name__ == '__main__':
    app.run(debug=True)