import os
import subprocess
import random
import time
import datetime
import re
import sys
from psql_utils import connect_to_database, update_or_insert_ip
from ovpn_downloader import download_and_extract_ovpn_configs, download_ovpn_if_needed
from openvpn_manager import establish_vpn_connection, is_vpn_active, disconnect_vpn, get_external_ip

# Variables
CREDENTIAL_FILE = "nord.creds"
OVPN_DIR = "ovpn_configs/ovpn_tcp"
LOG_FILE = "openvpn.log"
RESULT_FILE = "vpnlist.txt"

# Check for debug flag
DEBUG_MODE = False
if len(sys.argv) > 1 and sys.argv[1] == "-d":
    DEBUG_MODE = True

def debug_print(message):
    if DEBUG_MODE:
        print(f"{datetime.datetime.now()} + [Debug Mode]:{message}")
    else:
        # log_file.write(f"{datetime.datetime.now()} + [Debug Mode]:{message}\n")
        log_file.flush()  # Flush the buffer to ensure the message is written

# Open the log file in append mode if not in debug mode
log_file = None  # Define log_file in the global scope
if not DEBUG_MODE:
    log_file = open('nord-checker.log', 'a')
    # Redirect stdout and stderr to the log file
    sys.stdout = log_file
    sys.stderr = log_file

# Get current IP before starting (using get_external_ip)
CURRENT_IP = get_external_ip()
if CURRENT_IP is None:
    print(f"{datetime.datetime.now()} [Main Script]: Unable to get current IP. Exiting.")
    if not DEBUG_MODE:
        log_file.close()  # Close the log file if it was opened
    sys.exit(1)  # Exit if unable to get current IP
else:
    print(f"{datetime.datetime.now()} [Main Script]: Current IP before VPN connections: {CURRENT_IP}")
    if not DEBUG_MODE:
        log_file.flush()

# Terminate any existing OpenVPN connections
try:
    result = subprocess.run(["pgrep", "openvpn"], check=True, capture_output=True)
    pids = result.stdout.decode().strip().split('\n')  # Get PIDs as a list
    for pid in pids:
        subprocess.run(["kill", pid])
    print(f"{datetime.datetime.now()} [Main Script]: Existing OpenVPN connections terminated.")
    if not DEBUG_MODE:
        log_file.flush()
except subprocess.CalledProcessError:
    pass  # No openvpn process found

# Connect to PostgreSQL database
conn, cursor = connect_to_database()

# Download and extract OVPN configurations, and get the list of files to check
debug_print(f"{datetime.datetime.now()} [Main Script]: Downloading and extracting OVPN configurations...")
ovpn_files_to_check = download_and_extract_ovpn_configs(cursor, conn, debug_print=debug_print)

total_files = len(ovpn_files_to_check)
debug_print(f"{datetime.datetime.now()} [Main Script]: Found {total_files} OVPN files to check.")
print(f"{datetime.datetime.now()} [Main Script]: Found {total_files} OVPN files to check.")

# Process each OVPN file
FILE_NUM = 1
for OVPN_FILE in ovpn_files_to_check:
    OVPN_FILENAME = os.path.basename(OVPN_FILE)

    debug_print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Processing OVPN file...")

    # Check if the OVPN file exists, download if needed
    file_exists = download_ovpn_if_needed(OVPN_FILENAME, cursor, conn, debug_print=debug_print)

    if not file_exists:
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Skipping, file not found and removed from database.")
        FILE_NUM += 1
        continue

    # Establish VPN connection 
    connection_successful, connection_message = establish_vpn_connection(f"{OVPN_DIR}/{OVPN_FILE}", CREDENTIAL_FILE, LOG_FILE, debug_print=debug_print)

    if connection_successful:
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: {connection_message}")
    if not connection_successful:
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Error starting OpenVPN connection:{connection_message}")

        # Wait for a random time between 1 and 4 seconds
        sleep_time = random.randint(8, 15) 
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Waiting for {sleep_time} seconds before the next connection...")
        time.sleep(sleep_time)
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Resuming...")

        continue  # Skip to the next OVPN file

    # Check if the VPN connection is active (using the function from openvpn_manager.py)
    try:
        subprocess.run(["pgrep", "-f", OVPN_FILENAME], check=True, capture_output=True)

        # Check external IP (with validation and retries)
        external_ip = get_external_ip()

        if external_ip is None:
            print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Unable to get external IP. Skipping this OVPN file.")
            continue

        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: External IP via VPN: {external_ip}")

        # Update or insert into database
        update_or_insert_ip(cursor, conn, OVPN_FILENAME, external_ip)

    except subprocess.CalledProcessError:
        print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: VPN connection failed to establish.")

    # Disconnect VPN 
    disconnect_vpn()
    print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: VPN disconnected.")
    if not DEBUG_MODE:
        log_file.flush()
    # Wait for a random time between 5 and 8 seconds
    sleep_time = random.randint(5, 8)
    print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Waiting for {sleep_time} seconds before the next connection...")
    time.sleep(sleep_time)
    print(f"{datetime.datetime.now()} [{FILE_NUM}/{total_files}] [{OVPN_FILENAME}]: Resuming...")
    if not DEBUG_MODE:
        log_file.flush()
    # Increment file number
    FILE_NUM += 1

# Close the database connection
cursor.close()
conn.close()

# Close the log file if it was opened
if not DEBUG_MODE:
    log_file.close()