/**
 * @file autodock_gpu.cuh
 * @brief CUDA/CUDPP-accelerated AutoDock molecular docking engine
 * 
 * This header defines GPU-accelerated molecular docking algorithms using
 * CUDA and CUDPP primitives for high-performance parallel docking.
 * 
 * @authors OpenPeer AI, Riemann Computing Inc., Bleunomics, Andrew Magdy Kamal
 * @version 1.0.0
 * @date 2025
 */

#ifndef DOCKING_AT_HOME_AUTODOCK_GPU_CUH
#define DOCKING_AT_HOME_AUTODOCK_GPU_CUH

#include <cuda_runtime.h>
#include <cudpp.h>
#include <vector>
#include <string>

namespace docking_at_home {
namespace autodock {

/**
 * @struct Atom
 * @brief Represents an atom in 3D space
 */
struct Atom {
    float x, y, z;      // Coordinates
    int type;           // Atom type
    float charge;       // Partial charge
    float radius;       // Van der Waals radius
};

/**
 * @struct Ligand
 * @brief Represents a ligand molecule
 */
struct Ligand {
    std::vector<Atom> atoms;
    int num_rotatable_bonds;
    float center_x, center_y, center_z;
    std::string name;
};

/**
 * @struct Receptor
 * @brief Represents a receptor (protein) molecule
 */
struct Receptor {
    std::vector<Atom> atoms;
    float grid_min_x, grid_min_y, grid_min_z;
    float grid_max_x, grid_max_y, grid_max_z;
    float grid_spacing;
    std::string name;
};

/**
 * @struct DockingParameters
 * @brief Parameters for docking simulation
 */
struct DockingParameters {
    int num_runs;              // Number of docking runs
    int num_evals;             // Number of energy evaluations
    int population_size;       // GA population size
    float rmsd_tolerance;      // RMSD clustering tolerance
    int max_generations;       // Maximum GA generations
    float mutation_rate;       // GA mutation rate
    float crossover_rate;      // GA crossover rate
    bool use_local_search;     // Enable local search
    int num_threads_per_block; // CUDA threads per block
    int num_blocks;            // CUDA blocks
};

/**
 * @struct DockingPose
 * @brief Represents a docking pose (conformation)
 */
struct DockingPose {
    float translation[3];      // Translation vector
    float rotation[4];         // Quaternion rotation
    std::vector<float> torsions; // Torsion angles
    float binding_energy;      // Binding energy (kcal/mol)
    float intermolecular_energy;
    float internal_energy;
    float torsional_energy;
    float rank;
};

/**
 * @class AutoDockGPU
 * @brief GPU-accelerated AutoDock implementation
 */
class AutoDockGPU {
public:
    AutoDockGPU();
    ~AutoDockGPU();

    /**
     * @brief Initialize GPU resources
     * @param device_id CUDA device ID
     * @return true if initialization successful
     */
    bool initialize(int device_id = 0);

    /**
     * @brief Load ligand from PDBQT file
     * @param filename Path to ligand file
     * @param ligand Output ligand structure
     * @return true if loading successful
     */
    bool load_ligand(const std::string& filename, Ligand& ligand);

    /**
     * @brief Load receptor from PDBQT file
     * @param filename Path to receptor file
     * @param receptor Output receptor structure
     * @return true if loading successful
     */
    bool load_receptor(const std::string& filename, Receptor& receptor);

    /**
     * @brief Perform molecular docking
     * @param ligand Input ligand
     * @param receptor Input receptor
     * @param params Docking parameters
     * @param poses Output vector of docking poses
     * @return true if docking successful
     */
    bool dock(const Ligand& ligand, 
              const Receptor& receptor,
              const DockingParameters& params,
              std::vector<DockingPose>& poses);

    /**
     * @brief Get GPU device information
     * @return Device info string
     */
    std::string get_device_info();

    /**
     * @brief Get performance metrics
     * @return Metrics string
     */
    std::string get_performance_metrics();

    /**
     * @brief Cleanup GPU resources
     */
    void cleanup();

private:
    bool is_initialized_;
    int device_id_;
    cudaDeviceProp device_prop_;
    CUDPPHandle cudpp_handle_;
    
    // Device memory pointers
    Atom* d_ligand_atoms_;
    Atom* d_receptor_atoms_;
    float* d_energy_grid_;
    float* d_population_;
    float* d_energies_;
    
    // Host memory
    size_t ligand_atoms_size_;
    size_t receptor_atoms_size_;
    
    // Performance tracking
    float total_computation_time_;
    int total_evaluations_;

    // Private methods
    bool allocate_device_memory(const Ligand& ligand, const Receptor& receptor);
    bool transfer_to_device(const Ligand& ligand, const Receptor& receptor);
    bool compute_energy_grid(const Receptor& receptor);
    bool run_genetic_algorithm(const DockingParameters& params, 
                               std::vector<DockingPose>& poses);
    bool cluster_results(std::vector<DockingPose>& poses, float rmsd_tolerance);
    void free_device_memory();
};

// CUDA kernel declarations

/**
 * @brief Calculate pairwise energy between atoms (GPU kernel)
 */
__global__ void calculate_energy_kernel(
    const Atom* ligand_atoms,
    const Atom* receptor_atoms,
    int num_ligand_atoms,
    int num_receptor_atoms,
    float* energies
);

/**
 * @brief Genetic algorithm population evaluation (GPU kernel)
 */
__global__ void evaluate_population_kernel(
    const float* population,
    const Atom* ligand_atoms,
    const Atom* receptor_atoms,
    const float* energy_grid,
    float* fitness_values,
    int population_size,
    int num_genes
);

/**
 * @brief Genetic algorithm crossover operator (GPU kernel)
 */
__global__ void crossover_kernel(
    float* population,
    const float* parent_indices,
    float crossover_rate,
    int population_size,
    int num_genes,
    unsigned long long seed
);

/**
 * @brief Genetic algorithm mutation operator (GPU kernel)
 */
__global__ void mutation_kernel(
    float* population,
    float mutation_rate,
    int population_size,
    int num_genes,
    unsigned long long seed
);

/**
 * @brief Local search optimization (GPU kernel)
 */
__global__ void local_search_kernel(
    float* population,
    const float* energy_grid,
    float* fitness_values,
    int population_size,
    int num_genes,
    int num_iterations
);

/**
 * @brief RMSD calculation for clustering (GPU kernel)
 */
__global__ void rmsd_kernel(
    const DockingPose* poses,
    float* rmsd_matrix,
    int num_poses
);

/**
 * @brief Sort poses by energy using CUDPP
 */
bool sort_poses_by_energy(DockingPose* d_poses, int num_poses, CUDPPHandle cudpp);

/**
 * @brief Parallel reduction to find minimum energy using CUDPP
 */
bool find_min_energy(const float* d_energies, int num_energies, 
                     float& min_energy, CUDPPHandle cudpp);

} // namespace autodock
} // namespace docking_at_home

#endif // DOCKING_AT_HOME_AUTODOCK_GPU_CUH