message DetectionTask {
    string task_id = 1; // Unique correlation ID
    TaskType task_type = 2; // Type of operation
    optional ProcessFilter process_filter = 3; // Optional filtering
    optional HashCheck hash_check = 4; // Optional hash verification
    optional string metadata = 5; // Optional task metadata
}

message DetectionResult {
    string task_id = 1; // Matching correlation ID
    bool success = 2; // Operation success status
    optional string error_message = 3; // Error details if failed
    repeated ProcessRecord processes = 4; // Collected process data
    optional HashResult hash_result = 5; // Hash verification result
}

message ProcessRecord {
    uint32 pid = 1; // Process ID
    optional uint32 ppid = 2; // Parent process ID
    string name = 3; // Process name
    optional string executable_path = 4; // Full executable path
    repeated string command_line = 5; // Command line arguments
    optional int64 start_time = 6; // Start time (Unix timestamp)
    optional double cpu_usage = 7; // CPU usage percentage
    optional uint64 memory_usage = 8; // Memory usage in bytes
    optional string executable_hash = 9; // File hash (hex-encoded)
    optional string hash_algorithm = 10; // Hash algorithm name
    optional string user_id = 11; // User ID
    bool accessible = 12; // Data accessibility flag
    bool file_exists = 13; // Executable file existence
    int64 collection_time = 14; // Collection timestamp (millis)
}

enum TaskType {
    ENUMERATE_PROCESSES = 0; // List all accessible processes
    CHECK_PROCESS_HASH = 1; // Verify executable hash
    MONITOR_PROCESS_TREE = 2; // Monitor process hierarchy
    VERIFY_EXECUTABLE = 3; // Verify executable integrity
}

message ProcessFilter {
    repeated string process_names = 1; // Filter by process names
    repeated uint32 pids = 2; // Filter by process IDs
    optional string executable_pattern = 3; // Filter by path pattern
}

message HashCheck {
    string expected_hash = 1; // Expected hash value
    string hash_algorithm = 2; // Algorithm (e.g., "sha256")
    string executable_path = 3; // Path to verify
}

message HashResult {
    string hash_value = 1; // Computed hash
    string algorithm = 2; // Algorithm used
    string file_path = 3; // File path processed
    bool success = 4; // Computation success
    optional string error_message = 5; // Error details if failed
}

use daemoneye_lib::proto::{
    DetectionResult, DetectionTask, ProtoHashCheck, ProtoHashResult,
    ProtoProcessFilter, ProtoProcessRecord, ProtoTaskType,
};

use daemoneye_lib::models::process::ProcessRecord;
use daemoneye_lib::proto::ProtoProcessRecord;

fn convert_process_record() {
    // Convert native to protobuf
    let native_process = ProcessRecord::new(1234, "firefox".to_string());
    let proto_process: ProtoProcessRecord = native_process.into();

    // Convert protobuf to native
    let converted_back: ProcessRecord = proto_process.into();
}

fn create_tasks_and_results() {
    // Create enumeration task
    let task = DetectionTask::new_enumerate_processes("task-123", None);

    // Create hash check task
    let hash_check = ProtoHashCheck {
        expected_hash: "abc123...".to_string(),
        hash_algorithm: "sha256".to_string(),
        executable_path: "/usr/bin/firefox".to_string(),
    };
    let task = DetectionTask::new_hash_check("task-456", hash_check);

    // Create results
    let processes = vec![];
    let success = DetectionResult::success("task-123", processes);
    let failure = DetectionResult::failure("task-123", "Permission denied");
}

[dependencies]
prost = "0.13.5"
prost-types = "0.13.5"
serde = { version = "1.0", features = ["derive"] }

[build-dependencies]
prost-build = "0.13.5"

fn main() -> Result<(), Box<dyn std::error::Error>> {
    prost_build::Config::new()
        .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
        .protoc_arg("--experimental_allow_proto3_optional")
        .compile_protos(&["proto/ipc.proto"], &["proto/"])?;
    Ok(())
}

fn basic_process_enumeration() -> Result<(), Box<dyn std::error::Error>> {
    let task = DetectionTask::new_enumerate_processes("enum-001", None);
    let bytes = prost::Message::encode_to_vec(&task);
    // Send via IPC transport...

    // Deserialize response
    let result = DetectionResult::decode(&response_bytes[..])?;
    if result.success {
        for process in result.processes {
            println!("Process: {} (PID: {})", process.name, process.pid);
        }
    }
    Ok(())
}

use daemoneye_lib::proto::ProtoProcessFilter;

fn filtered_process_collection() {
    let filter = ProtoProcessFilter {
        process_names: vec!["firefox".to_string(), "chrome".to_string()],
        pids: vec![],
        executable_pattern: Some("/usr/bin/*".to_string()),
    };
    let task = DetectionTask::new_enumerate_processes("filtered-001", Some(filter));
}

use daemoneye_lib::proto::ProtoHashCheck;

fn hash_verification() {
    let hash_check = ProtoHashCheck {
        expected_hash: "a1b2c3d4...".to_string(),
        hash_algorithm: "sha256".to_string(),
        executable_path: "/usr/bin/suspicious".to_string(),
    };
    let task = DetectionTask::new_hash_check("verify-001", hash_check);
}