package com.vpnpanel;

import android.content.Context;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.os.Build;
import android.util.Log;

/**
 * Kill Switch Manager
 * قطع اینترنت در صورت disconnect شدن VPN
 */
public class KillSwitchManager {
    private static final String TAG = "KillSwitchManager";
    private static final String PREFS_NAME = "KillSwitchPrefs";
    private static final String KEY_ENABLED = "kill_switch_enabled";
    
    private Context context;
    private SharedPreferences prefs;
    private ConnectivityManager connectivityManager;
    private NetworkCallback networkCallback;
    private boolean isEnabled;
    private boolean vpnConnected;
    
    public KillSwitchManager(Context context) {
        this.context = context;
        this.prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        this.isEnabled = prefs.getBoolean(KEY_ENABLED, false);
    }
    
    /**
     * فعال/غیرفعال کردن Kill Switch
     */
    public void setEnabled(boolean enabled) {
        this.isEnabled = enabled;
        prefs.edit().putBoolean(KEY_ENABLED, enabled).apply();
        
        if (enabled) {
            startMonitoring();
        } else {
            stopMonitoring();
        }
        
        Log.d(TAG, "Kill Switch " + (enabled ? "enabled" : "disabled"));
    }
    
    public boolean isEnabled() {
        return isEnabled;
    }
    
    /**
     * اعلام اتصال VPN
     */
    public void onVpnConnected() {
        this.vpnConnected = true;
        Log.d(TAG, "VPN connected");
    }
    
    /**
     * اعلام قطع VPN
     */
    public void onVpnDisconnected() {
        this.vpnConnected = false;
        
        if (isEnabled) {
            blockInternet();
        }
        
        Log.d(TAG, "VPN disconnected");
    }
    
    /**
     * شروع مانیتورینگ شبکه
     */
    private void startMonitoring() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            NetworkRequest request = new NetworkRequest.Builder()
                    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                    .build();
            
            networkCallback = new NetworkCallback();
            connectivityManager.registerNetworkCallback(request, networkCallback);
            
            Log.d(TAG, "Network monitoring started");
        }
    }
    
    /**
     * توقف مانیتورینگ شبکه
     */
    private void stopMonitoring() {
        if (networkCallback != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            try {
                connectivityManager.unregisterNetworkCallback(networkCallback);
                Log.d(TAG, "Network monitoring stopped");
            } catch (Exception e) {
                Log.e(TAG, "Error stopping monitoring: " + e.getMessage());
            }
        }
    }
    
    /**
     * مسدود کردن اینترنت
     */
    private void blockInternet() {
        Log.w(TAG, "Blocking internet due to VPN disconnection");
        
        // روش‌های مختلف برای مسدود کردن:
        
        // 1. استفاده از iptables (نیاز به root)
        // Runtime.getRuntime().exec("iptables -A OUTPUT -j DROP");
        
        // 2. استفاده از VpnService.Builder
        // در VPN Service می‌توان route ها را تنظیم کرد
        
        // 3. حذف Default Route
        // در صورت disconnect شدن VPN، route پیش‌فرض حذف می‌شود
        
        // نمایش نوتیفیکیشن به کاربر
        showKillSwitchNotification();
    }
    
    /**
     * باز کردن اینترنت
     */
    public void unblockInternet() {
        Log.d(TAG, "Unblocking internet");
        
        // حذف قوانین iptables یا بازگردانی route ها
        
        hideKillSwitchNotification();
    }
    
    /**
     * نمایش نوتیفیکیشن Kill Switch
     */
    private void showKillSwitchNotification() {
        // نمایش notification به کاربر
        // "اتصال VPN قطع شد. اینترنت مسدود شده است."
    }
    
    /**
     * پنهان کردن نوتیفیکیشن
     */
    private void hideKillSwitchNotification() {
        // پنهان کردن notification
    }
    
    /**
     * Network Callback برای مانیتورینگ
     */
    private class NetworkCallback extends ConnectivityManager.NetworkCallback {
        @Override
        public void onAvailable(Network network) {
            Log.d(TAG, "Network available: " + network);
            
            // بررسی اینکه آیا VPN است یا نه
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);
                if (capabilities != null) {
                    boolean isVpn = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN);
                    
                    if (!isVpn && isEnabled && vpnConnected) {
                        // شبکه غیر VPN available شده، در حالی که باید VPN باشد
                        Log.w(TAG, "Non-VPN network detected while VPN should be active");
                        // می‌توان در اینجا اقدامات امنیتی انجام داد
                    }
                }
            }
        }
        
        @Override
        public void onLost(Network network) {
            Log.d(TAG, "Network lost: " + network);
            
            // بررسی اینکه آیا VPN قطع شده
            if (vpnConnected && isEnabled) {
                blockInternet();
            }
        }
    }
}