#ifndef OTP_H
#define OTP_H

////////////////////////////////////////////////////////////////////////////////
//      OTP CIPHER - FUNCTION PROTOTYPES HEADER
//      One Time Pad Implementation v0.2.109
//      
//      This header file contains all function prototypes extracted from otp.c
//      Organized by functional categories for better maintainability
////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <termios.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <time.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>

// Constants
#define MAX_INPUT_SIZE 4096
#define MAX_LINE_LENGTH 1024
#define MAX_HASH_LENGTH 65
#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
#define DEFAULT_PADS_DIR "pads"
#define FILES_DIR "files"
#define MAX_ENTROPY_BUFFER 32768  // 32KB entropy buffer

////////////////////////////////////////////////////////////////////////////////
//      TYPE DEFINITIONS
////////////////////////////////////////////////////////////////////////////////

// Decrypt operation modes for universal decrypt function
typedef enum {
    DECRYPT_MODE_INTERACTIVE,    // Interactive text decryption with prompts
    DECRYPT_MODE_SILENT,         // Silent text decryption (no prompts/labels)
    DECRYPT_MODE_FILE_TO_TEXT,   // File to text output with prompts
    DECRYPT_MODE_FILE_TO_FILE    // File to file output (binary)
} decrypt_mode_t;

// Pad filter types for selection functions
typedef enum {
    PAD_FILTER_ALL,           // Show all pads
    PAD_FILTER_UNUSED_ONLY    // Show only unused pads (0% usage)
} pad_filter_type_t;

// Enhanced entropy system state structure
typedef struct {
    size_t target_bytes;           // Target entropy to collect
    size_t collected_bytes;        // Bytes collected so far
    size_t unique_keys;           // Number of unique keys pressed
    double collection_start_time; // Start timestamp
    double last_keypress_time;    // Last keypress timestamp
    unsigned char quality_score;  // Entropy quality (0-100)
    int auto_complete_enabled;    // Allow auto-complete at minimum
    unsigned char key_histogram[256]; // Track key frequency
} entropy_collection_state_t;

////////////////////////////////////////////////////////////////////////////////
//      CORE APPLICATION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Main application entry points
int main(int argc, char* argv[]);
int interactive_mode(void);
int command_line_mode(int argc, char* argv[]);
int pipe_mode(int argc, char* argv[], const char* piped_text);

////////////////////////////////////////////////////////////////////////////////
//      INPUT/OUTPUT DETECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Stdin detection functions
int has_stdin_data(void);
char* read_stdin_text(void);

////////////////////////////////////////////////////////////////////////////////
//      PREFERENCES MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Configuration and preferences handling
int load_preferences(void);
int save_preferences(void);
char* get_preference(const char* key);
int set_preference(const char* key, const char* value);
char* get_default_pad_path(void);
int set_default_pad_path(const char* pad_path);

////////////////////////////////////////////////////////////////////////////////
//      HARDWARE DETECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// OTP thumb drive detection function
int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size);

////////////////////////////////////////////////////////////////////////////////
//      USB DRIVE MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
//      EXTERNAL TOOL INTEGRATION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Editor and file manager functions
char* get_preferred_editor(void);
char* get_preferred_file_manager(void);
int launch_text_editor(const char* initial_content, char* result_buffer, size_t buffer_size);
int launch_file_manager(const char* start_directory, char* selected_file, size_t buffer_size);

////////////////////////////////////////////////////////////////////////////////
//      CORE CRYPTOGRAPHIC OPERATIONS
////////////////////////////////////////////////////////////////////////////////

// Primary encryption/decryption functions
int generate_pad(uint64_t size_bytes, int show_progress);
int encrypt_text(const char* pad_identifier, const char* input_text);
int decrypt_text(const char* pad_identifier, const char* encrypted_message);
int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor);
int decrypt_file(const char* input_file, const char* output_file);
int decrypt_binary_file(FILE* input_fp, const char* output_file);
int decrypt_ascii_file(const char* input_file, const char* output_file);

////////////////////////////////////////////////////////////////////////////////
//      ENHANCED ENTROPY SYSTEM FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Entropy source types
typedef enum {
    ENTROPY_SOURCE_KEYBOARD = 1,
    ENTROPY_SOURCE_DICE = 2,
    ENTROPY_SOURCE_TRUERNG = 3
} entropy_source_t;

// Terminal control for entropy collection
int setup_raw_terminal(struct termios* original_termios);
void restore_terminal(struct termios* original_termios);

// Entropy collection and feedback
int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
                                 size_t* collected_bytes, int allow_early_exit);
void display_entropy_progress(const entropy_collection_state_t* state);
void draw_progress_bar(double percentage, int width);
void draw_quality_bar(double quality, int width, const char* label);

// TrueRNG Device Constants (updated to match otp.c implementation)
#define TRUERNG_VID "04D8"
#define TRUERNG_PID "F5FE"
#define TRUERNGPRO_VID "16D0"
#define TRUERNGPRO_PID "0AA0"
#define TRUERNGPROV2_VID "04D8"
#define TRUERNGPROV2_PID "EBB5"

// TrueRNG Device Type enumeration
typedef enum {
    TRUERNG_ORIGINAL = 1,
    TRUERNG_PRO = 2,
    TRUERNG_PRO_V2 = 3
} truerng_device_type_t;

// TrueRNG entropy collection functions (updated to match implementation)
int find_truerng_port(char* port_path, size_t port_path_size, truerng_device_type_t* device_type);
int setup_truerng_serial_port(const char* port_path);
int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);
const char* get_truerng_device_name(truerng_device_type_t device_type);
int read_usb_device_info(const char* port_name, char* vid, char* pid);

// Dice entropy collection functions (updated to match implementation)
int collect_dice_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);

// Unified entropy collection interface (updated to match implementation)
int collect_entropy_by_source(entropy_source_t source, unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);

// Entropy quality calculation
double calculate_timing_quality(const entropy_collection_state_t* state);
double calculate_variety_quality(const entropy_collection_state_t* state);
unsigned char calculate_overall_quality(const entropy_collection_state_t* state);
double get_precise_time(void);

// Entropy processing and application
int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_size,
                          unsigned char key[32], unsigned char nonce[12]);
int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data,
                      size_t entropy_size, int show_progress);
int handle_add_entropy_to_pad(const char* pad_chksum);

// Enhanced entropy system helper functions
int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum);
int rename_pad_files_safely(const char* old_chksum, const char* new_chksum);
int is_pad_unused(const char* pad_chksum);

////////////////////////////////////////////////////////////////////////////////
//      DIRECTORY MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Directory handling and path management
int ensure_pads_directory(void);
void get_pad_path(const char* chksum, char* pad_path, char* state_path);
const char* get_files_directory(void);
void get_default_file_path(const char* filename, char* result_path, size_t result_size);
void get_directory_display(const char* file_path, char* result, size_t result_size);

////////////////////////////////////////////////////////////////////////////////
//      UTILITY FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// General utility and helper functions
uint64_t parse_size_string(const char* size_str);
char* find_pad_by_prefix(const char* prefix);
int show_pad_info(const char* chksum);
void show_progress(uint64_t current, uint64_t total, time_t start_time);

////////////////////////////////////////////////////////////////////////////////
//      FILE OPERATIONS
////////////////////////////////////////////////////////////////////////////////

// File state and checksum operations
int read_state_offset(const char* pad_chksum, uint64_t* offset);
int write_state_offset(const char* pad_chksum, uint64_t offset);
int calculate_checksum(const char* filename, char* checksum_hex);

////////////////////////////////////////////////////////////////////////////////
//      UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
////////////////////////////////////////////////////////////////////////////////

// Consolidated cryptographic operations
int universal_xor_operation(const unsigned char* data, size_t data_len,
                           const unsigned char* pad_data, unsigned char* result);
int parse_ascii_message(const char* message, char* chksum, uint64_t* offset, char* base64_data);
int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsigned char** pad_data);
int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned char* encrypted_data,
                        size_t data_length, char** ascii_output);
int validate_pad_integrity(const char* pad_path, const char* expected_chksum);

// Universal decrypt function - consolidates all decrypt operations
int universal_decrypt(const char* input_data, const char* output_target, decrypt_mode_t mode);

////////////////////////////////////////////////////////////////////////////////
//      BASE64 ENCODING FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Custom base64 implementation
char* custom_base64_encode(const unsigned char* input, int length);
unsigned char* custom_base64_decode(const char* input, int* output_length);

////////////////////////////////////////////////////////////////////////////////
//      MENU SYSTEM FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Interactive menu interface functions
void show_main_menu(void);
int handle_generate_menu(void);
int handle_encrypt_menu(void);
int handle_decrypt_menu(void);
int handle_pads_menu(void);
int handle_text_encrypt(void);
int handle_file_encrypt(void);

////////////////////////////////////////////////////////////////////////////////
//      ENHANCED INPUT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Advanced input handling
int get_filename_with_default(const char* prompt, const char* default_path, char* result, size_t result_size);

////////////////////////////////////////////////////////////////////////////////
//      PAD SELECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Unified pad selection interface
char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel);

////////////////////////////////////////////////////////////////////////////////
//      USAGE AND HELP FUNCTIONS
////////////////////////////////////////////////////////////////////////////////

// Help and usage display
void print_usage(const char* program_name);

#endif // OTP_H