#!/usr/bin/perl

use strict;

use warnings;

use DBI;

use JSON;

use File::Slurp;

use Getopt::Long;

use POSIX qw(strftime);

use Time::HiRes qw(sleep);

# autoSMART Collector Daemon

# Version: 1.0

# Description: Automated SMART data collection daemon

my $config_file;

my $debug = (defined $ENV{AUTOSMART_DEBUG} && $ENV{AUTOSMART_DEBUG} eq 'true') ? 1 : 0;

my $foreground = 0;

GetOptions(

    'config=s' => \$config_file,

    'debug'    => \$debug,

    'foreground' => \$foreground

) or die "Usage: $0 --config <file> [--debug] [--foreground]\n";

if (defined $ENV{AUTOSMART_DEBUG}) {

    if ($ENV{AUTOSMART_DEBUG} eq 'true') {

        $debug = 1;

        log_message("AUTOSMART_DEBUG enabled via /etc/default/autonas or environment");

    } else {

        $debug = 0;

        log_message("AUTOSMART_DEBUG disabled via /etc/default/autonas or environment");

    }

}

die "Configuration file required\n" unless $config_file;

die "Configuration file not found: $config_file\n" unless -f $config_file;

# Load configuration

my $config = load_config($config_file);

my $node_id = $config->{node}{id} || `hostname -s`;

chomp $node_id;

log_message("Starting autoSMART collector daemon on node: $node_id");

log_message("Configuration loaded from: $config_file");

# Main collection loop

my $last_full_scan = 0;

my $scan_interval = $config->{node}{scan_interval} || 300;

my $full_scan_interval = $config->{collection}{full_scan_interval} || 3600;

while (1) {

    eval {

        my $current_time = time();

        my $force_full = ($current_time - $last_full_scan) >= $full_scan_interval;

        if ($force_full) {

            log_message("Performing full SMART scan (forced)");

            $last_full_scan = $current_time;

        }

        collect_smart_data($force_full);

    };

    if ($@) {

        log_message("ERROR: Collection failed: $@");

    }

    log_message("Sleeping for $scan_interval seconds...") if $debug;

    sleep($scan_interval);

}

sub collect_smart_data {

    my ($force_full) = @_;

    log_message("[DEBUG] Starting data collection cycle, force_full=" . ($force_full ? 'true' : 'false')) if $debug;

    # Connect to database

    my $dsn = "DBI:Pg:host=$config->{database}{host};dbname=$config->{database}{database}";

    log_message("[DEBUG] Connecting to database: $dsn") if $debug;

    my $dbh = DBI->connect($dsn, $config->{database}{user}, $config->{database}{password},

                          {RaiseError => 1, AutoCommit => 1})

        or die "Database connection failed: $DBI::errstr";

    log_message("✓ Database connected") if $debug;

    # Test database connectivity

    if ($debug) {

        eval {

            my $sth = $dbh->prepare("SELECT COUNT(*) FROM hdd_inventory");

            $sth->execute();

            my ($count) = $sth->fetchrow_array();

            log_message("[DEBUG] Database test: found $count HDDs in inventory");

            $sth = $dbh->prepare("SELECT COUNT(*) FROM hdd_presence WHERE is_current = TRUE");

            $sth->execute();

            my ($presence_count) = $sth->fetchrow_array();

            log_message("[DEBUG] Database test: found $presence_count current HDD presence records");

        };

        if ($@) {

            log_message("[DEBUG] Database test failed: $@");

        }

    }

    # Scan for devices

    my @devices = glob('/dev/sd?');

    push @devices, glob('/dev/nvme?n?');

    log_message("[DEBUG] Found " . scalar(@devices) . " potential devices: " . join(', ', @devices)) if $debug;

    foreach my $device (@devices) {

        if (-b $device) {

            log_message("[DEBUG] Processing block device: $device") if $debug;

        } else {

            log_message("[DEBUG] Skipping non-block device: $device") if $debug;

            next;

        }

        eval {

            process_device($dbh, $device, $force_full);

        };

        if ($@) {

            log_message("ERROR processing device $device: $@");

        }

    }

    $dbh->disconnect();

    log_message("Collection cycle complete") if $debug;

}

sub process_device {

    my ($dbh, $device, $force_full) = @_;

    log_message("[DEBUG] process_device: Processing $device") if $debug;

    # Get SMART data

    my $smartctl_cmd = "smartctl -A -i -H $device 2>&1";

    log_message("[DEBUG] Running: $smartctl_cmd") if $debug;

    my @smart_output = `$smartctl_cmd`;

    my $exit_code = $? >> 8;

    if (!@smart_output) {

        log_message("[DEBUG] No SMART output for $device") if $debug;

        return;

    }

    log_message("[DEBUG] Got " . scalar(@smart_output) . " lines of SMART output from $device (exit code: $exit_code)") if $debug;

    # Check if smartctl indicates the device doesn't support SMART

    my $smart_output_text = join('', @smart_output);

    if ($smart_output_text =~ /SMART support is.*Unavailable|Device does not support SMART|No such device/) {

        log_message("[DEBUG] Device $device does not support SMART or is not accessible") if $debug;

        return;

    }

    my ($model, $serial, $temp, %smart_params);

    foreach my $line (@smart_output) {

        chomp $line;

        if ($line =~ /Device Model:\s+(.+)/) {

            $model = $1;

            log_message("[DEBUG] Found model: $model") if $debug;

        } elsif ($line =~ /Serial Number:\s+(.+)/) {

            $serial = $1;

            log_message("[DEBUG] Found serial: $serial") if $debug;

        } elsif ($line =~ /^\s*(\d+)\s+(.+?)\s+0x\w+\s+\d+\s+\d+\s+\d+\s+\w+\s+\w+\s+\w+\s+(\d+)/) {

            # Old format: ID ATTRIBUTE_NAME 0xXXXX DDD DDD DDD Pre-fail Always - RAW_VALUE

            my ($id, $name, $raw) = ($1, $2, $3);

            $name =~ s/\s+/_/g;

            $smart_params{$name} = $raw;

            if ($debug && scalar(keys %smart_params) <= 5) {

                log_message("[DEBUG] SMART param (old format): $name = $raw");

            }

            if ($name =~ /Temperature|Temp/i) {

                $temp = $raw if (!defined $temp || $raw > 0);

            }

        } elsif ($line =~ /^\s*(\d+)\s+(.+?)\s+0x\w+\s+\d+\s+\d+\s+\d+\s+\S+\s+\S+\s+\S+\s+(\d+)/) {

            # New format: ID ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE

            my ($id, $name, $raw) = ($1, $2, $3);

            $name =~ s/\s+/_/g;

            $smart_params{$name} = $raw;

            if ($debug && scalar(keys %smart_params) <= 5) {

                log_message("[DEBUG] SMART param (new format): $name = $raw");

            }

            if ($name =~ /Temperature|Temp/i) {

                $temp = $raw if (!defined $temp || $raw > 0);

            }

        }

    }

    if (!$model || !$serial) {

        log_message("[DEBUG] Missing critical data for $device - model: " . ($model || 'NULL') . ", serial: " . ($serial || 'NULL')) if $debug;

        return;

    }

    if (!%smart_params) {

        log_message("[DEBUG] No SMART parameters found for $device") if $debug;

        return;

    }

    log_message("[DEBUG] Parsed device data - Model: $model, Serial: $serial, Temperature: " . ($temp || 'NULL') . ", Parameters: " . scalar(keys %smart_params)) if $debug;

    return unless ($model && $serial && %smart_params);

    log_message("Processing: $model ($serial) @ $device") if $debug;

    # Get or create HDD inventory entry

    my $hdd_id = get_or_create_hdd($dbh, $serial, $model, $device);

    # Check if we should store this reading

    my $params_json = encode_json(\%smart_params);

    if (!$force_full && !$config->{node}{store_unchanged}) {

        # Check for recent identical reading

        my $sth = $dbh->prepare("

            SELECT id FROM smart_readings

            WHERE hdd_id = ? AND parameters_json = ?

            AND timestamp > NOW() - INTERVAL '1 hour'

            LIMIT 1

        ");

        $sth->execute($hdd_id, $params_json);

        if ($sth->fetchrow_array()) {

            log_message("  Skipping unchanged parameters") if $debug;

            return;

        }

    }

    # Store SMART reading

    my $reading_type = $force_full ? 'full' : 'differential';

    my $sth = $dbh->prepare("

        INSERT INTO smart_readings (hdd_id, serial_number, device_path, node_id, timestamp, temperature, parameters_json, reading_type)

        VALUES (?, ?, ?, ?, NOW(), ?, ?::jsonb, ?)

        RETURNING id

    ");

    my $reading_id = $dbh->selectrow_array($sth, undef, $hdd_id, $serial, $device, $node_id, $temp || 0, $params_json, $reading_type);

    log_message("  ✓ SMART reading stored (ID: $reading_id, temp: " . ($temp || 0) . "°C, type: $reading_type)") if $debug;

}

sub get_or_create_hdd {

    my ($dbh, $serial, $model, $device_path) = @_;

    log_message("[DEBUG] get_or_create_hdd: serial=$serial, model=$model, device=$device_path, node=$node_id") if $debug;

    # Check if HDD exists

    my $sth = $dbh->prepare("SELECT id FROM hdd_inventory WHERE serial_number = ?");

    $sth->execute($serial);

    my ($hdd_id) = $sth->fetchrow_array();

    log_message("[DEBUG] HDD lookup result: hdd_id=" . ($hdd_id || 'NULL') . " for serial=$serial") if $debug;

    if ($hdd_id) {

        log_message("[DEBUG] Found existing HDD with id=$hdd_id, updating location and presence") if $debug;

        # Update current location in inventory

        $dbh->do("UPDATE hdd_inventory SET current_device_path = ?, current_node_id = ?, last_seen = NOW()

                  WHERE id = ?", undef, $device_path, $node_id, $hdd_id);

        log_message("[DEBUG] Updated hdd_inventory location for hdd_id=$hdd_id") if $debug;

        # Mark all previous hdd_presence as historic for this serial

        my $affected_rows = $dbh->do("UPDATE hdd_presence SET is_current = FALSE WHERE serial_number = ? AND is_current = TRUE AND node <> ?", undef, $serial, $node_id);

        log_message("[DEBUG] Marked $affected_rows historic hdd_presence records for serial=$serial") if $debug;

        # Check if there is already a current presence for this serial/node

        my $sth2 = $dbh->prepare("SELECT id FROM hdd_presence WHERE serial_number = ? AND node = ? AND is_current = TRUE");

        $sth2->execute($serial, $node_id);

        my ($presence_id) = $sth2->fetchrow_array();

        if ($presence_id) {

            log_message("[DEBUG] Found existing presence record id=$presence_id, updating data_end") if $debug;

            # Update data_end

            $dbh->do("UPDATE hdd_presence SET data_end = NOW() WHERE id = ?", undef, $presence_id);

            log_message("[DEBUG] Updated data_end for presence_id=$presence_id") if $debug;

        } else {

            log_message("[DEBUG] No existing presence for serial=$serial node=$node_id, creating new record") if $debug;

            # Create new presence record

            $dbh->do("UPDATE hdd_presence SET is_current = FALSE WHERE serial_number = ? AND is_current = TRUE", undef, $serial);

            $sth2 = $dbh->prepare("INSERT INTO hdd_presence (serial_number, node, data_start, data_end, is_current) VALUES (?, ?, NOW(), NOW(), TRUE)");

            $sth2->execute($serial, $node_id);

            my $new_presence_id = $dbh->last_insert_id(undef, undef, 'hdd_presence', undef);

            log_message("[DEBUG] Created new hdd_presence record with id=$new_presence_id for serial=$serial node=$node_id") if $debug;

        }

        return $hdd_id;

    }

    # Create new HDD entry

    log_message("[DEBUG] Creating new HDD entry for serial=$serial model=$model") if $debug;

    $sth = $dbh->prepare("

        INSERT INTO hdd_inventory (serial_number, model_name, current_device_path, current_node_id,

                                   first_seen, last_seen)

        VALUES (?, ?, ?, ?, NOW(), NOW())

        RETURNING id

    ");

    my $new_id = $dbh->selectrow_array($sth, undef, $serial, $model, $device_path, $node_id);

    log_message("[DEBUG] Created new HDD inventory entry with id=$new_id") if $debug;

    # Mark all previous hdd_presence as historic for this serial

    my $affected_rows = $dbh->do("UPDATE hdd_presence SET is_current = FALSE WHERE serial_number = ? AND is_current = TRUE", undef, $serial);

    log_message("[DEBUG] Marked $affected_rows historic hdd_presence records for new serial=$serial") if $debug;

    # Create new presence record

    my $sth2 = $dbh->prepare("INSERT INTO hdd_presence (serial_number, node, data_start, data_end, is_current) VALUES (?, ?, NOW(), NOW(), TRUE)");

    $sth2->execute($serial, $node_id);

    my $new_presence_id = $dbh->last_insert_id(undef, undef, 'hdd_presence', undef);

    log_message("[DEBUG] Created new hdd_presence record with id=$new_presence_id for new serial=$serial node=$node_id") if $debug;

    return $new_id;

}

sub load_config {

    my ($file) = @_;

    my $content = read_file($file);

    my %config;

    # Simple YAML-like parser

    my $current_section;

    foreach my $line (split /\n/, $content) {

        $line =~ s/^\s+|\s+$//g;

        next if $line =~ /^#/ || $line eq '';

        if ($line =~ /^(\w+):$/) {

            $current_section = $1;

        } elsif ($line =~ /^\s*(\w+):\s*(.+)$/) {

            $config{$current_section}{$1} = $2;

        }

    }

    return \%config;

}

sub log_message {

    my ($message) = @_;

    my $timestamp = strftime("%Y-%m-%d %H:%M:%S", localtime);

    print "[$timestamp] $message\n";

}

__END__

=head1 NAME

smart-collector-daemon.pl - autoSMART SMART Data Collection Daemon

=head1 SYNOPSIS

smart-collector-daemon.pl --config <config_file> [--debug] [--foreground]

=head1 DESCRIPTION

Automated daemon for collecting SMART data from storage devices and storing

in PostgreSQL database with differential storage optimization.

=head1 OPTIONS

=over 4

=item --config <file>

Configuration file path (required)

=item --debug

Enable debug logging

=item --foreground

Run in foreground (don't daemonize)

=back

=head1 AUTHOR

autoSMART v1.0 - Hardware-based HDD tracking system

=cut