use std::{io, thread};
use std::ffi::OsString;
use std::net::UdpSocket;
use std::path::PathBuf;
use std::time::Duration;

use console::style;
use fs2::FileExt;
use windows_service::Error;
use windows_service::service::{
    ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceState, ServiceType,
};
use windows_service::service_manager::{ServiceManager, ServiceManagerAccess};

use switch::core::{Config, Switch};

use crate::{BaseArgs, Commands, config};
use crate::command::{command, CommandEnum};

pub mod service;
mod windows_admin_check;

pub const SERVICE_FLAG: &'static str = "start_switch_service_v1_";
pub const SERVICE_NAME: &'static str = "switch-service-v1";
pub const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;

fn admin_check() -> bool {
    if !windows_admin_check::is_app_elevated() {
        println!(
            "{}",
            style("请使用管理员权限运行(Please run with administrator privileges)").red()
        );
        true
    } else {
        false
    }
}

fn not_started() -> bool {
    match service_state() {
        Ok(state) => {
            if state == ServiceState::Running {
                return false;
            } else {
                println!("服务未启动")
            }
        }
        Err(e) => {
            println!("{:?}", e);
        }
    }
    return true;
}

pub fn main0(base_args: BaseArgs) {
    match base_args.command {
        Commands::Start(args) => {
            if admin_check() {
                return;
            }
            {
                // 允许应用通过防火墙
                let _udp = UdpSocket::bind("0.0.0.0:0").unwrap();
            }
            let out_log = args.log;
            match config::default_config(args) {
                Ok(start_config) => {
                    match service_state() {
                        Ok(state) => {
                            if state == ServiceState::Stopped {
                                if let Err(e) = config::save_config(config::ArgsConfig::new(start_config.tap,
                                                                                            start_config.token.clone(),
                                                                                            start_config.name.clone(),
                                                                                            start_config.server,
                                                                                            &start_config.nat_test_server,
                                                                                            start_config.device_id.clone(),
                                )) {
                                    log::error!("{:?}",e);
                                    return;
                                }
                                match start(out_log) {
                                    Ok(_) => {
                                        //需要检查启动状态
                                        thread::sleep(Duration::from_secs(2));
                                        println!("{}", style("启动成功(Start successfully)").green())
                                    }
                                    Err(e) => {
                                        log::error!("{:?}", e);
                                    }
                                }
                            } else {
                                println!("服务未停止(Service not stopped)");
                            }
                        }
                        Err(e) => {
                            match e {
                                Error::Winapi(ref e) => {
                                    if let Some(code) = e.raw_os_error() {
                                        if code == 1060 {
                                            //指定的服务未安装。
                                            println!(
                                                "{}",
                                                style("服务未安装，在当前进程启动(The service is not installed and started in the current process)").red()
                                            );
                                            let config = Config::new(
                                                start_config.tap,
                                                start_config.token,
                                                start_config.device_id,
                                                start_config.name,
                                                start_config.server,
                                                start_config.nat_test_server,
                                            );
                                            let lock = match config::lock_file() {
                                                Ok(lock) => {
                                                    lock
                                                }
                                                Err(e) => {
                                                    log::error!("文件锁定失败:{:?}",e);
                                                    println!("文件锁定失败:{:?}", e);
                                                    return;
                                                }
                                            };
                                            if lock.try_lock_exclusive().is_err() {
                                                println!("{}", style("文件被重复打开").red());
                                                return;
                                            }
                                            match Switch::start(config) {
                                                Ok(switch) => {
                                                    crate::console_listen(&switch);
                                                }
                                                Err(e) => {
                                                    log::error!("{:?}", e);
                                                    println!("启动switch失败:{:?}", e);
                                                }
                                            }
                                            lock.unlock().unwrap();
                                            return;
                                        }
                                    }
                                }
                                _ => {}
                            }
                            println!("{:?}", e);
                        }
                    }
                }
                Err(e) => {
                    println!("{}", style(&e).red());
                    log::error!("{:?}", e);
                }
            };
            pause();
        }
        Commands::Stop => {
            if not_started() {
                return;
            }
            if admin_check() {
                return;
            }
            match stop() {
                Ok(_) => {
                    println!("{}", style("停止成功(Stopped successfully)").green())
                }
                Err(e) => {
                    log::error!("{:?}", e);
                }
            }
            pause();
        }
        Commands::Install(args) => {
            if admin_check() {
                return;
            }
            let path: PathBuf = args.path.into();
            if !path.exists() {
                std::fs::create_dir_all(&path).unwrap();
            }
            if !path.is_dir() {
                println!("参数必须为文件目录(Parameter must be a file directory)");
            } else {
                if let Err(e) = install(path, args.auto) {
                    log::error!("{:?}", e);
                } else {
                    println!("{}", style("安装成功(Installation succeeded)").green())
                }
            }
            pause();
        }
        Commands::Uninstall => {
            if admin_check() {
                return;
            }
            if let Err(e) = uninstall() {
                log::error!("{:?}", e);
            } else {
                println!("{}", style("卸载成功(Uninstall succeeded)").green())
            }
            pause();
        }
        Commands::Config(args) => {
            if let Err(e) = change(args.auto) {
                log::error!("{:?}", e);
            } else {
                println!("{}", style("配置成功(Config succeeded)").green())
            }
            pause();
        }
        Commands::Route => {
            if not_started() {
                return;
            }
            command(CommandEnum::Route);
        }
        Commands::List { all } => {
            if not_started() {
                return;
            }
            if all {
                command(CommandEnum::ListAll);
            } else {
                command(CommandEnum::List);
            }
        }
        Commands::Status => {
            if not_started() {
                return;
            }
            command(CommandEnum::Status);
        }
    }
}

fn pause() {
    println!(
        "{}",
        style("按任意键退出(Press any key to exit)...").green()
    );
    use console::Term;
    let term = Term::stdout();
    let _ = term.read_char().unwrap();
}

fn install(path: PathBuf, auto: bool) -> Result<(), Error> {
    let manager_access = ServiceManagerAccess::CONNECT | ServiceManagerAccess::CREATE_SERVICE;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
    let current_exe_path = std::env::current_exe().unwrap();
    let service_path = path.join("switch-service-v1.exe");
    std::fs::copy(current_exe_path, service_path.as_path()).unwrap();
    if let Err(e) = std::fs::copy("wintun.dll", path.join("wintun.dll").as_path()) {
        if e.kind() == io::ErrorKind::NotFound {
            println!("Not fount 'wintun.dll'. Please put 'wintun.dll' in the current directory");
            std::process::exit(0);
        } else {
            panic!("{:?}", e)
        }
    }
    let mut launch_arguments = Vec::new();
    launch_arguments.push(OsString::from(SERVICE_FLAG));
    launch_arguments.push(OsString::from(
        dirs::home_dir().unwrap().join(".switch").to_str().unwrap(),
    ));
    let start_type = if auto {
        ServiceStartType::AutoStart
    } else {
        ServiceStartType::OnDemand
    };
    let service_info = ServiceInfo {
        name: OsString::from(SERVICE_NAME),
        display_name: OsString::from("switch service v1"),
        service_type: SERVICE_TYPE,
        start_type,
        error_control: ServiceErrorControl::Normal,
        executable_path: service_path.into(),
        launch_arguments,
        dependencies: vec![],
        account_name: None, // run as System
        account_password: None,
    };
    let service = service_manager.create_service(&service_info, ServiceAccess::CHANGE_CONFIG)?;
    service.set_description("A VPN")?;
    Ok(())
}

fn change(auto: bool) -> Result<(), Error> {
    let manager_access = ServiceManagerAccess::CONNECT;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;

    let service_access = ServiceAccess::QUERY_CONFIG | ServiceAccess::CHANGE_CONFIG;
    let service = service_manager.open_service(SERVICE_NAME, service_access)?;
    let config = service.query_config()?;
    let start_type = if auto {
        ServiceStartType::AutoStart
    } else {
        ServiceStartType::OnDemand
    };
    let mut launch_arguments = Vec::new();
    launch_arguments.push(OsString::from(SERVICE_FLAG));
    launch_arguments.push(OsString::from(
        dirs::home_dir().unwrap().join(".switch").to_str().unwrap(),
    ));
    let service_info = ServiceInfo {
        name: OsString::from(SERVICE_NAME),
        display_name: config.display_name,
        service_type: SERVICE_TYPE,
        start_type,
        error_control: config.error_control,
        executable_path: config.executable_path,
        launch_arguments,
        dependencies: config.dependencies,
        account_name: None, // run as System
        account_password: None,
    };
    service.change_config(&service_info)?;
    Ok(())
}

fn uninstall() -> Result<(), Error> {
    let manager_access = ServiceManagerAccess::CONNECT;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;

    let service_access = ServiceAccess::QUERY_STATUS | ServiceAccess::STOP | ServiceAccess::DELETE;
    let service = service_manager.open_service(SERVICE_NAME, service_access)?;

    let service_status = service.query_status()?;
    if service_status.current_state != ServiceState::Stopped {
        service.stop()?;
        // Wait for service to stop
        thread::sleep(Duration::from_secs(1));
    }
    service.delete()?;
    Ok(())
}

fn start(out_log: bool) -> Result<(), Error> {
    let manager_access = ServiceManagerAccess::CONNECT;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
    let service = service_manager.open_service(SERVICE_NAME, ServiceAccess::START)?;
    if out_log {
        service.start(&["log"])
    } else {
        service.start(&[""])
    }
}

fn service_state() -> Result<ServiceState, Error> {
    let manager_access = ServiceManagerAccess::CONNECT;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;

    let service_access = ServiceAccess::QUERY_STATUS;
    let service = service_manager.open_service(SERVICE_NAME, service_access)?;
    let service_status = service.query_status()?;
    return Ok(service_status.current_state);
}

fn stop() -> Result<(), Error> {
    let manager_access = ServiceManagerAccess::CONNECT;
    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
    let service = service_manager.open_service(SERVICE_NAME, ServiceAccess::STOP)?;
    service.stop()?;
    Ok(())
}