package com.vpnpanel;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Split Tunneling Manager
 * انتخاب اپ‌هایی که از VPN استفاده کنند
 */
public class SplitTunnelingManager {
    private static final String TAG = "SplitTunneling";
    private static final String PREFS_NAME = "SplitTunnelingPrefs";
    private static final String KEY_ENABLED = "split_tunneling_enabled";
    private static final String KEY_MODE = "split_tunneling_mode"; // "include" or "exclude"
    private static final String KEY_APPS = "split_tunneling_apps";
    
    private Context context;
    private SharedPreferences prefs;
    private Gson gson;
    
    public enum Mode {
        INCLUDE, // فقط اپ‌های انتخاب شده از VPN استفاده کنند
        EXCLUDE  // همه اپ‌ها به جز انتخاب شده‌ها از VPN استفاده کنند
    }
    
    public SplitTunnelingManager(Context context) {
        this.context = context;
        this.prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.gson = new Gson();
    }
    
    /**
     * فعال/غیرفعال کردن Split Tunneling
     */
    public void setEnabled(boolean enabled) {
        prefs.edit().putBoolean(KEY_ENABLED, enabled).apply();
        Log.d(TAG, "Split Tunneling " + (enabled ? "enabled" : "disabled"));
    }
    
    public boolean isEnabled() {
        return prefs.getBoolean(KEY_ENABLED, false);
    }
    
    /**
     * تنظیم حالت Split Tunneling
     */
    public void setMode(Mode mode) {
        prefs.edit().putString(KEY_MODE, mode.name()).apply();
        Log.d(TAG, "Split Tunneling mode: " + mode.name());
    }
    
    public Mode getMode() {
        String mode = prefs.getString(KEY_MODE, Mode.EXCLUDE.name());
        return Mode.valueOf(mode);
    }
    
    /**
     * اضافه کردن اپ به لیست
     */
    public void addApp(String packageName) {
        Set<String> apps = getSelectedApps();
        apps.add(packageName);
        saveSelectedApps(apps);
        Log.d(TAG, "Added app: " + packageName);
    }
    
    /**
     * حذف اپ از لیست
     */
    public void removeApp(String packageName) {
        Set<String> apps = getSelectedApps();
        apps.remove(packageName);
        saveSelectedApps(apps);
        Log.d(TAG, "Removed app: " + packageName);
    }
    
    /**
     * دریافت لیست اپ‌های انتخاب شده
     */
    public Set<String> getSelectedApps() {
        String json = prefs.getString(KEY_APPS, "[]");
        Type type = new TypeToken<HashSet<String>>(){}.getType();
        Set<String> apps = gson.fromJson(json, type);
        return apps != null ? apps : new HashSet<>();
    }
    
    /**
     * ذخیره لیست اپ‌های انتخاب شده
     */
    private void saveSelectedApps(Set<String> apps) {
        String json = gson.toJson(apps);
        prefs.edit().putString(KEY_APPS, json).apply();
    }
    
    /**
     * بررسی اینکه آیا اپ باید از VPN استفاده کند
     */
    public boolean shouldUseVPN(String packageName) {
        if (!isEnabled()) {
            return true; // اگر Split Tunneling غیرفعال است، همه از VPN استفاده می‌کنند
        }
        
        Set<String> selectedApps = getSelectedApps();
        Mode mode = getMode();
        
        if (mode == Mode.INCLUDE) {
            // فقط اپ‌های انتخاب شده از VPN استفاده کنند
            return selectedApps.contains(packageName);
        } else {
            // همه به جز اپ‌های انتخاب شده از VPN استفاده کنند
            return !selectedApps.contains(packageName);
        }
    }
    
    /**
     * دریافت تمام اپ‌های نصب شده
     */
    public List<AppInfo> getInstalledApps() {
        List<AppInfo> appList = new ArrayList<>();
        PackageManager pm = context.getPackageManager();
        
        List<ApplicationInfo> packages = pm.getInstalledApplications(PackageManager.GET_META_DATA);
        
        for (ApplicationInfo app : packages) {
            // فقط اپ‌های کاربر (نه سیستمی)
            if ((app.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
                AppInfo appInfo = new AppInfo();
                appInfo.packageName = app.packageName;
                appInfo.appName = pm.getApplicationLabel(app).toString();
                appInfo.icon = pm.getApplicationIcon(app);
                appInfo.isSelected = getSelectedApps().contains(app.packageName);
                
                appList.add(appInfo);
            }
        }
        
        // مرتب‌سازی بر اساس نام
        appList.sort((a, b) -> a.appName.compareToIgnoreCase(b.appName));
        
        return appList;
    }
    
    /**
     * کلاس اطلاعات اپ
     */
    public static class AppInfo {
        public String packageName;
        public String appName;
        public android.graphics.drawable.Drawable icon;
        public boolean isSelected;
    }
    
    /**
     * دریافت package names برای VpnService.Builder
     */
    public String[] getPackageNamesForVPN() {
        if (!isEnabled()) {
            return new String[0];
        }
        
        Set<String> selectedApps = getSelectedApps();
        
        if (getMode() == Mode.EXCLUDE) {
            // در حالت Exclude، باید لیست اپ‌هایی که از VPN استفاده می‌کنند را برگردانیم
            // این لیست شامل همه اپ‌ها به جز selected apps است
            List<AppInfo> allApps = getInstalledApps();
            List<String> vpnApps = new ArrayList<>();
            
            for (AppInfo app : allApps) {
                if (!selectedApps.contains(app.packageName)) {
                    vpnApps.add(app.packageName);
                }
            }
            
            return vpnApps.toArray(new String[0]);
        } else {
            // در حالت Include، فقط selected apps از VPN استفاده می‌کنند
            return selectedApps.toArray(new String[0]);
        }
    }
    
    /**
     * پاک کردن تمام تنظیمات
     */
    public void clear() {
        prefs.edit().clear().apply();
        Log.d(TAG, "Split Tunneling settings cleared");
    }
}