// Copyright 2021 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

use crate::common::{parse_file_to_u64, set_epp};
use crate::memory::{
    calculate_available_memory_kb, calculate_reserved_free_kb, parse_margins, parse_meminfo,
    parse_psi_memory, MemInfo,
};

use crate::gpu_freq_scaling::amd_device::AmdDeviceConfig;
use crate::gpu_freq_scaling::{evaluate_gpu_frequency, init_gpu_params, init_gpu_scaling_thread};
use tempfile::TempDir;

#[test]
fn test_parse_file_to_u64() {
    assert_eq!(
        parse_file_to_u64("123".to_string().as_bytes()).unwrap(),
        123
    );
    assert_eq!(
        parse_file_to_u64("456\n789".to_string().as_bytes()).unwrap(),
        456
    );
    assert!(parse_file_to_u64("".to_string().as_bytes()).is_err());
    assert!(parse_file_to_u64("abc".to_string().as_bytes()).is_err());
}

#[test]
fn test_calculate_reserved_free_kb() {
    let mock_partial_zoneinfo = r#"
Node 0, zone      DMA
  pages free     3968
        min      137
        low      171
        high     205
        spanned  4095
        present  3999
        managed  3976
        protection: (0, 1832, 3000, 3786)
Node 0, zone    DMA32
  pages free     422432
        min      16270
        low      20337
        high     24404
        spanned  1044480
        present  485541
        managed  469149
        protection: (0, 0, 1953, 1500)
Node 0, zone   Normal
  pages free     21708
        min      17383
        low      21728
        high     26073
        spanned  524288
        present  524288
        managed  501235
        protection: (0, 0, 0, 0)"#;
    let page_size_kb = 4;
    let high_watermarks = 205 + 24404 + 26073;
    let lowmem_reserves = 3786 + 1953;
    let reserved = calculate_reserved_free_kb(mock_partial_zoneinfo.as_bytes()).unwrap();
    assert_eq!(reserved, (high_watermarks + lowmem_reserves) * page_size_kb);
}

#[test]
fn test_parse_psi_memory() {
    let mock_psi_memory = r#"
some avg10=57.25 avg60=35.97 avg300=10.18 total=32748793
full avg10=29.29 avg60=19.01 avg300=5.44 total=17589167"#;
    let pressure = parse_psi_memory(mock_psi_memory.as_bytes()).unwrap();
    assert!((pressure - 57.25).abs() < f64::EPSILON);
}

#[test]
fn test_parse_meminfo() {
    let mock_meminfo = r#"
MemTotal:        8025656 kB
MemFree:         4586928 kB
MemAvailable:    6704404 kB
Buffers:          659640 kB
Cached:          1949056 kB
SwapCached:            0 kB
Active:          1430416 kB
Inactive:        1556968 kB
Active(anon):     489640 kB
Inactive(anon):    29188 kB
Active(file):     940776 kB
Inactive(file):  1527780 kB
Unevictable:      151128 kB
Mlocked:           41008 kB
SwapTotal:      11756332 kB
SwapFree:       11756332 kB
Dirty:              5712 kB
Writeback:             0 kB
AnonPages:        529800 kB
Mapped:           321468 kB
Shmem:            140156 kB
Slab:             169252 kB
SReclaimable:     115540 kB
SUnreclaim:        53712 kB
KernelStack:        7072 kB
PageTables:        13340 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:    15769160 kB
Committed_AS:    2483600 kB
VmallocTotal:   34359738367 kB
VmallocUsed:           0 kB
VmallocChunk:          0 kB
Percpu:             2464 kB
AnonHugePages:     40960 kB
ShmemHugePages:        0 kB
ShmemPmdMapped:        0 kB
DirectMap4k:      170216 kB
DirectMap2M:     5992448 kB
DirectMap1G:     3145728 kB"#;
    let meminfo = parse_meminfo(mock_meminfo.as_bytes()).unwrap();
    assert_eq!(meminfo.free, 4586928);
    assert_eq!(meminfo.active_anon, 489640);
    assert_eq!(meminfo.inactive_anon, 29188);
    assert_eq!(meminfo.active_file, 940776);
    assert_eq!(meminfo.inactive_file, 1527780);
    assert_eq!(meminfo.dirty, 5712);
    assert_eq!(meminfo.swap_free, 11756332);
}

#[test]
fn test_calculate_available_memory_kb() {
    let mut info = MemInfo::default();
    let min_filelist = 400 * 1024;
    let reserved_free = 0;
    let ram_swap_weight = 4;

    // Available determined by file cache.
    info.active_file = 500 * 1024;
    info.inactive_file = 500 * 1024;
    info.dirty = 10 * 1024;
    let file = info.active_file + info.inactive_file;
    let available =
        calculate_available_memory_kb(&info, reserved_free, min_filelist, ram_swap_weight);
    assert_eq!(available, file - min_filelist - info.dirty);

    // Available determined by swap free.
    info.swap_free = 1200 * 1024;
    info.active_anon = 1000 * 1024;
    info.inactive_anon = 1000 * 1024;
    info.active_file = 0;
    info.inactive_file = 0;
    info.dirty = 0;
    let available =
        calculate_available_memory_kb(&info, reserved_free, min_filelist, ram_swap_weight);
    assert_eq!(available, info.swap_free / ram_swap_weight);

    // Available determined by anonymous.
    info.swap_free = 6000 * 1024;
    info.active_anon = 500 * 1024;
    info.inactive_anon = 500 * 1024;
    let anon = info.active_anon + info.inactive_anon;
    let available =
        calculate_available_memory_kb(&info, reserved_free, min_filelist, ram_swap_weight);
    assert_eq!(available, anon / ram_swap_weight);

    // When ram_swap_weight is 0, swap is ignored in available.
    info.swap_free = 1200 * 1024;
    info.active_anon = 1000 * 1024;
    info.inactive_anon = 1000 * 1024;
    info.active_file = 500 * 1024;
    info.inactive_file = 500 * 1024;
    let file = info.active_file + info.inactive_file;
    let ram_swap_weight = 0;
    let available =
        calculate_available_memory_kb(&info, reserved_free, min_filelist, ram_swap_weight);
    assert_eq!(available, file - min_filelist);
}

#[test]
fn test_parse_margins() {
    assert!(parse_margins("".to_string().as_bytes()).is_err());
    assert!(parse_margins("123 4a6".to_string().as_bytes()).is_err());
    assert!(parse_margins("123.2 412.3".to_string().as_bytes()).is_err());
    assert!(parse_margins("123".to_string().as_bytes()).is_err());

    let margins = parse_margins("123 456".to_string().as_bytes()).unwrap();
    assert_eq!(margins.len(), 2);
    assert_eq!(margins[0], 123);
    assert_eq!(margins[1], 456);
}

#[test]
fn test_set_epp() {
    let dir = TempDir::new().unwrap();

    // Create the fake sysfs paths in temp directory
    let mut tpb0 = dir.path().to_owned();
    tpb0.push("sys/devices/system/cpu/cpufreq/policy0/");
    // let dirpath_str0 = tpb0.clone().into_os_string().into_string().unwrap();
    std::fs::create_dir_all(&tpb0).unwrap();

    let mut tpb1 = dir.path().to_owned();
    tpb1.push("sys/devices/system/cpu/cpufreq/policy1/");
    std::fs::create_dir_all(&tpb1).unwrap();

    // Set the EPP
    set_epp(dir.path().to_str().unwrap(), "179").unwrap();

    // Verify that files were written
    tpb0.push("energy_performance_preference");
    tpb1.push("energy_performance_preference");
    assert_eq!(std::fs::read_to_string(&tpb0).unwrap(), "179".to_string());
    assert_eq!(std::fs::read_to_string(&tpb1).unwrap(), "179".to_string());
}

#[test]
fn test_amd_device_true() {
    let mock_cpuinfo = r#"
processor	: 0
vendor_id	: AuthenticAMD
cpu family	: 23
model		: 24"#;
    assert_eq!(
        true,
        AmdDeviceConfig::has_amd_tag_in_cpu_info(mock_cpuinfo.as_bytes())
    );
}

#[test]
fn test_amd_device_false() {
    // Incorrect vendor ID
    let mock_cpuinfo = r#"
processor	: 0
vendor_id	: GenuineIntel
cpu family	: 23
model		: 24"#;
    assert_eq!(
        false,
        AmdDeviceConfig::has_amd_tag_in_cpu_info(mock_cpuinfo.as_bytes())
    );

    // missing vendor ID
    assert_eq!(
        false,
        AmdDeviceConfig::has_amd_tag_in_cpu_info("".to_string().as_bytes())
    );
    assert_eq!(
        false,
        AmdDeviceConfig::has_amd_tag_in_cpu_info("processor: 0".to_string().as_bytes())
    );
}

#[test]
fn test_amd_parse_sclk_valid() {
    let dev: AmdDeviceConfig = AmdDeviceConfig::new("mock_file", "mock_sclk");

    // trailing space is intentional, reflects sysfs output.
    let mock_sclk = r#"
0: 200Mhz 
1: 700Mhz *
2: 1400Mhz "#;

    let (sclk, sel) = dev.parse_sclk(mock_sclk.as_bytes()).unwrap();
    assert_eq!(1, sel);
    assert_eq!(3, sclk.len());
    assert_eq!(200, sclk[0]);
    assert_eq!(700, sclk[1]);
    assert_eq!(1400, sclk[2]);
}

#[test]
fn test_amd_parse_sclk_invalid() {
    let dev: AmdDeviceConfig = AmdDeviceConfig::new("mock_file", "mock_sclk");

    // trailing space is intentional, reflects sysfs output.
    let mock_sclk = r#"
0: nonint 
1: 700Mhz *
2: 1400Mhz "#;
    assert!(dev.parse_sclk(mock_sclk.as_bytes()).is_err());
    assert!(dev.parse_sclk("nonint".to_string().as_bytes()).is_err());
    assert!(dev.parse_sclk("0: 1400 ".to_string().as_bytes()).is_err());
    assert!(dev.parse_sclk("0: 1400 *".to_string().as_bytes()).is_err());
    assert!(dev
        .parse_sclk("x: nonint *".to_string().as_bytes())
        .is_err());
}

#[test]
fn test_amd_device_filter_pass() {
    let dev: AmdDeviceConfig = AmdDeviceConfig::new("mock_file", "mock_sclk");

    let mock_cpuinfo = r#"
processor	: 0
vendor_id	: AuthenticAMD
cpu family	: 23
model		: 24
model name	: AMD Ryzen 7 3700C  with Radeon Vega Mobile Gfx
stepping	: 1
microcode	: 0x8108109"#;

    assert_eq!(
        true,
        dev.is_supported_dev_family(mock_cpuinfo.as_bytes())
            .unwrap()
    );
    assert_eq!(
        true,
        dev.is_supported_dev_family("model name	: AMD Ryzen 5 3700C".as_bytes())
            .unwrap()
    );
}

#[test]
fn test_amd_device_filter_fail() {
    let dev: AmdDeviceConfig = AmdDeviceConfig::new("mock_file", "mock_sclk");

    let mock_cpuinfo = r#"
processor	: 0
vendor_id	: AuthenticAMD
cpu family	: 23
model		: 24
model name	: AMD Ryzen 3 3700C  with Radeon Vega Mobile Gfx
stepping	: 1
microcode	: 0x8108109"#;

    assert_eq!(
        false,
        dev.is_supported_dev_family(mock_cpuinfo.as_bytes())
            .unwrap()
    );
    assert_eq!(
        false,
        dev.is_supported_dev_family("model name	: AMD Ryzen 5 2700C".as_bytes())
            .unwrap()
    );
    assert_eq!(
        false,
        dev.is_supported_dev_family("model name	: AMD Ryzen 3 3700C".as_bytes())
            .unwrap()
    );
    assert_eq!(
        false,
        dev.is_supported_dev_family("model name	: malformed".as_bytes())
            .unwrap()
    );
    assert_eq!(false, dev.is_supported_dev_family("".as_bytes()).unwrap());
}

#[test]
#[allow(unused_must_use)]
fn test_gpu_thread_on_off() {
    println!("test gpu thread");
    let config = init_gpu_params().unwrap();

    // TODO: break this function to make is unit testable
    evaluate_gpu_frequency(&config, 150);
    let game_mode_on = Arc::new(AtomicBool::new(true));
    let game_mode_on_clone = Arc::clone(&game_mode_on);

    init_gpu_scaling_thread(game_mode_on_clone, 1000);
    thread::sleep(Duration::from_millis(500));
    game_mode_on.store(false, Ordering::Relaxed);
    thread::sleep(Duration::from_millis(500));

    println!("gpu thread exit gracefully");
}