#!/usr/bin/perl

use strict;

use warnings;

use DBI;

use Getopt::Long;

use Config::Simple;

use JSON::XS;

use POSIX qw(strftime);

=head1 NAME

autosmart-report.pl - Generate comprehensive reports for autoSMART system

=head1 SYNOPSIS

    autosmart-report.pl [OPTIONS]

=head1 OPTIONS

    --config-dir DIR     Configuration directory (default: /etc/autosmart)

    --report TYPE        Report type: summary, detailed, health, alerts, trends

    --device PATH        Report for specific device only

    --days N            Days of history to include (default: 30)

    --format FORMAT     Output format: text, html, json (default: text)

    --output FILE       Write to file instead of stdout

    --help              Show this help

=head1 DESCRIPTION

Generate various reports from autoSMART data including drive health summaries,

detailed SMART analysis, alert history, and trend analysis.

=cut

# Configuration

my $config_dir = '/etc/autosmart';

my $report_type = 'summary';

my $specific_device = '';

my $days = 30;

my $format = 'text';

my $output_file = '';

my $help = 0;

GetOptions(

    'config-dir=s' => \$config_dir,

    'report=s'     => \$report_type,

    'device=s'     => \$specific_device,

    'days=i'       => \$days,

    'format=s'     => \$format,

    'output=s'     => \$output_file,

    'help'         => \$help,

) or die "Error parsing command line arguments\n";

if ($help) {

    print_help();

    exit 0;

}

# Validate options

unless ($report_type =~ /^(summary|detailed|health|alerts|trends)$/) {

    die "Invalid report type: $report_type\n";

}

unless ($format =~ /^(text|html|json)$/) {

    die "Invalid format: $format\n";

}

# Connect to database

my $db_config = "$config_dir/database.conf";

unless (-f $db_config) {

    die "Database configuration not found: $db_config\n";

}

my $cfg = Config::Simple->new($db_config);

my $dsn = sprintf("DBI:Pg:database=%s;host=%s;port=%s",

    $cfg->param('database.database'),

    $cfg->param('database.host'),

    $cfg->param('database.port')

);

my $dbh = DBI->connect(

    $dsn,

    $cfg->param('database.username'),

    $cfg->param('database.password'),

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

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

# Generate report

my $report_data = generate_report($dbh, $report_type, $specific_device, $days);

# Output report

my $output_handle = \*STDOUT;

if ($output_file) {

    open $output_handle, '>', $output_file

        or die "Cannot open output file $output_file: $!\n";

}

if ($format eq 'json') {

    output_json($output_handle, $report_data);

} elsif ($format eq 'html') {

    output_html($output_handle, $report_data, $report_type);

} else {

    output_text($output_handle, $report_data, $report_type);

}

close $output_handle if $output_file;

$dbh->disconnect();

=head2 generate_report

Generate report data based on type

=cut

sub generate_report {

    my ($dbh, $type, $device, $days) = @_;

    my $data = {

        report_type => $type,

        generated_at => time(),

        days_included => $days,

        specific_device => $device,

    };

    if ($type eq 'summary') {

        $data->{summary} = get_system_summary($dbh, $days);

    } elsif ($type eq 'detailed') {

        $data->{drives} = get_detailed_drive_info($dbh, $device, $days);

    } elsif ($type eq 'health') {

        $data->{health} = get_health_overview($dbh, $device);

    } elsif ($type eq 'alerts') {

        $data->{alerts} = get_alert_history($dbh, $device, $days);

    } elsif ($type eq 'trends') {

        $data->{trends} = get_trend_analysis($dbh, $device, $days);

    }

    return $data;

}

=head2 get_system_summary

Get high-level system summary

=cut

sub get_system_summary {

    my ($dbh, $days) = @_;

    my $summary = {};

    # Drive counts by status

    my $sth = $dbh->prepare(q{

        SELECT status, COUNT(*) as count

        FROM hdd_inventory

        GROUP BY status

    });

    $sth->execute();

    $summary->{drive_counts} = {};

    while (my $row = $sth->fetchrow_hashref()) {

        $summary->{drive_counts}->{$row->{status}} = $row->{count};

    }

    # Recent predictions summary

    $sth = $dbh->prepare(q{

        SELECT risk_level, COUNT(*) as count

        FROM predictions

        WHERE timestamp >= NOW() - INTERVAL ? DAY

        GROUP BY risk_level

    });

    $sth->execute($days);

    $summary->{recent_predictions} = {};

    while (my $row = $sth->fetchrow_hashref()) {

        $summary->{recent_predictions}->{$row->{risk_level}} = $row->{count};

    }

    # Recent alerts

    $sth = $dbh->prepare(q{

        SELECT alert_type, COUNT(*) as count

        FROM alert_history

        WHERE sent_at >= NOW() - INTERVAL ? DAY

        GROUP BY alert_type

    });

    $sth->execute($days);

    $summary->{recent_alerts} = {};

    while (my $row = $sth->fetchrow_hashref()) {

        $summary->{recent_alerts}->{$row->{alert_type}} = $row->{count};

    }

    # Data collection stats

    $sth = $dbh->prepare(q{

        SELECT

            COUNT(*) as total_readings,

            COUNT(DISTINCT device_path) as devices_with_data,

            AVG(CASE WHEN collection_ok THEN 1.0 ELSE 0.0 END) * 100 as success_rate

        FROM smart_readings

        WHERE timestamp >= NOW() - INTERVAL ? DAY

    });

    $sth->execute($days);

    if (my $row = $sth->fetchrow_hashref()) {

        $summary->{collection_stats} = {

            total_readings => $row->{total_readings},

            devices_with_data => $row->{devices_with_data},

            success_rate => sprintf("%.1f", $row->{success_rate} || 0),

        };

    }

    return $summary;

}

=head2 get_detailed_drive_info

Get detailed information for drives

=cut

sub get_detailed_drive_info {

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

    my $sql = q{

        SELECT

            hi.device_path,

            hi.model_name,

            hi.serial_number,

            hi.size_gb,

            hi.status,

            hi.first_seen,

            hi.last_seen,

            COUNT(sr.id) as reading_count,

            AVG(sr.temperature) as avg_temperature,

            MAX(sr.temperature) as max_temperature

        FROM hdd_inventory hi

        LEFT JOIN smart_readings sr ON hi.device_path = sr.device_path

            AND sr.timestamp >= NOW() - INTERVAL ? DAY

    };

    my @params = ($days);

    if ($device) {

        $sql .= " WHERE hi.device_path = ?";

        push @params, $device;

    }

    $sql .= q{

        GROUP BY hi.device_path, hi.model_name, hi.serial_number,

                 hi.size_gb, hi.status, hi.first_seen, hi.last_seen

        ORDER BY hi.device_path

    };

    my $sth = $dbh->prepare($sql);

    $sth->execute(@params);

    my @drives = ();

    while (my $row = $sth->fetchrow_hashref()) {

        # Get latest prediction

        my $pred_sth = $dbh->prepare(q{

            SELECT risk_level, confidence, timestamp

            FROM predictions

            WHERE device_path = ?

            ORDER BY timestamp DESC

            LIMIT 1

        });

        $pred_sth->execute($row->{device_path});

        if (my $pred = $pred_sth->fetchrow_hashref()) {

            $row->{latest_prediction} = $pred;

        }

        # Get recent alerts

        my $alert_sth = $dbh->prepare(q{

            SELECT COUNT(*) as alert_count

            FROM alert_history

            WHERE device_path = ?

            AND sent_at >= NOW() - INTERVAL ? DAY

        });

        $alert_sth->execute($row->{device_path}, $days);

        if (my $alert = $alert_sth->fetchrow_hashref()) {

            $row->{recent_alert_count} = $alert->{alert_count};

        }

        push @drives, $row;

    }

    return \@drives;

}

=head2 get_health_overview

Get current health overview

=cut

sub get_health_overview {

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

    my $sql = q{

        SELECT * FROM drive_health_summary

    };

    my @params = ();

    if ($device) {

        $sql .= " WHERE device_path = ?";

        push @params, $device;

    }

    $sql .= " ORDER BY device_path";

    my $sth = $dbh->prepare($sql);

    $sth->execute(@params);

    my @health_data = ();

    while (my $row = $sth->fetchrow_hashref()) {

        push @health_data, $row;

    }

    return \@health_data;

}

=head2 get_alert_history

Get alert history

=cut

sub get_alert_history {

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

    my $sql = q{

        SELECT

            ah.device_path,

            ah.alert_type,

            ah.risk_level,

            ah.message,

            ah.sent_at,

            ah.acknowledged,

            ah.acknowledged_by,

            hi.model_name

        FROM alert_history ah

        JOIN hdd_inventory hi ON ah.device_path = hi.device_path

        WHERE ah.sent_at >= NOW() - INTERVAL ? DAY

    };

    my @params = ($days);

    if ($device) {

        $sql .= " AND ah.device_path = ?";

        push @params, $device;

    }

    $sql .= " ORDER BY ah.sent_at DESC";

    my $sth = $dbh->prepare($sql);

    $sth->execute(@params);

    my @alerts = ();

    while (my $row = $sth->fetchrow_hashref()) {

        push @alerts, $row;

    }

    return \@alerts;

}

=head2 get_trend_analysis

Get trend analysis data

=cut

sub get_trend_analysis {

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

    # This is a simplified trend analysis

    # In production, you might want more sophisticated analysis

    my $sql = q{

        SELECT

            device_path,

            DATE(timestamp) as date,

            AVG(temperature) as avg_temp,

            COUNT(*) as reading_count

        FROM smart_readings

        WHERE timestamp >= NOW() - INTERVAL ? DAY

    };

    my @params = ($days);

    if ($device) {

        $sql .= " AND device_path = ?";

        push @params, $device;

    }

    $sql .= q{

        GROUP BY device_path, DATE(timestamp)

        ORDER BY device_path, date

    };

    my $sth = $dbh->prepare($sql);

    $sth->execute(@params);

    my %trends = ();

    while (my $row = $sth->fetchrow_hashref()) {

        push @{$trends{$row->{device_path}}}, {

            date => $row->{date},

            avg_temp => sprintf("%.1f", $row->{avg_temp} || 0),

            reading_count => $row->{reading_count},

        };

    }

    return \%trends;

}

=head2 output_text

Output report as text

=cut

sub output_text {

    my ($fh, $data, $type) = @_;

    print $fh "\n" . "="x80 . "\n";

    print $fh "autoSMART System Report - " . ucfirst($type) . "\n";

    print $fh "Generated: " . strftime("%Y-%m-%d %H:%M:%S", localtime($data->{generated_at})) . "\n";

    print $fh "Time Period: Last $data->{days_included} days\n";

    print $fh "="x80 . "\n\n";

    if ($type eq 'summary') {

        output_summary_text($fh, $data->{summary});

    } elsif ($type eq 'detailed') {

        output_detailed_text($fh, $data->{drives});

    } elsif ($type eq 'health') {

        output_health_text($fh, $data->{health});

    } elsif ($type eq 'alerts') {

        output_alerts_text($fh, $data->{alerts});

    } elsif ($type eq 'trends') {

        output_trends_text($fh, $data->{trends});

    }

}

=head2 output_summary_text

Output summary in text format

=cut

sub output_summary_text {

    my ($fh, $summary) = @_;

    print $fh "SYSTEM OVERVIEW\n";

    print $fh "-"x40 . "\n";

    print $fh "Drive Status:\n";

    foreach my $status (sort keys %{$summary->{drive_counts}}) {

        printf $fh "  %-10s: %d drives\n", ucfirst($status), $summary->{drive_counts}->{$status};

    }

    if (%{$summary->{recent_predictions}}) {

        print $fh "\nRecent Risk Predictions:\n";

        foreach my $level (qw(critical high moderate low)) {

            next unless $summary->{recent_predictions}->{$level};

            printf $fh "  %-10s: %d drives\n", ucfirst($level), $summary->{recent_predictions}->{$level};

        }

    }

    if (%{$summary->{recent_alerts}}) {

        print $fh "\nRecent Alerts:\n";

        foreach my $type (sort keys %{$summary->{recent_alerts}}) {

            printf $fh "  %-15s: %d alerts\n", $type, $summary->{recent_alerts}->{$type};

        }

    }

    if ($summary->{collection_stats}) {

        my $stats = $summary->{collection_stats};

        print $fh "\nData Collection:\n";

        print $fh "  Total readings: $stats->{total_readings}\n";

        print $fh "  Devices monitored: $stats->{devices_with_data}\n";

        print $fh "  Success rate: $stats->{success_rate}%\n";

    }

    print $fh "\n";

}

=head2 output_json

Output report as JSON

=cut

sub output_json {

    my ($fh, $data) = @_;

    my $json = JSON::XS->new->pretty->encode($data);

    print $fh $json;

}

=head2 output_html

Output report as HTML (basic implementation)

=cut

sub output_html {

    my ($fh, $data, $type) = @_;

    print $fh <<'EOF';

<!DOCTYPE html>

<html>

<head>

    <title>autoSMART Report</title>

    <style>

        body { font-family: Arial, sans-serif; margin: 20px; }

        table { border-collapse: collapse; width: 100%; }

        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }

        th { background-color: #f2f2f2; }

        .critical { color: #d32f2f; font-weight: bold; }

        .high { color: #f57c00; font-weight: bold; }

        .moderate { color: #fbc02d; }

        .low { color: #388e3c; }

    </style>

</head>

<body>

EOF

    print $fh "<h1>autoSMART Report - " . ucfirst($type) . "</h1>\n";

    print $fh "<p>Generated: " . strftime("%Y-%m-%d %H:%M:%S", localtime($data->{generated_at})) . "</p>\n";

    # Basic HTML output - could be expanded significantly

    print $fh "<pre>" . encode_json($data) . "</pre>\n";

    print $fh "</body></html>\n";

}

# Additional text output functions would go here...

sub output_detailed_text {

    my ($fh, $drives) = @_;

    # Implementation for detailed drive output

    print $fh "DETAILED DRIVE INFORMATION\n";

    print $fh "-"x40 . "\n";

    foreach my $drive (@$drives) {

        print $fh "Device: $drive->{device_path}\n";

        print $fh "Model: " . ($drive->{model_name} || 'Unknown') . "\n";

        print $fh "Serial: " . ($drive->{serial_number} || 'Unknown') . "\n";

        print $fh "Status: $drive->{status}\n";

        if ($drive->{latest_prediction}) {

            print $fh "Latest Risk: $drive->{latest_prediction}->{risk_level}\n";

        }

        print $fh "\n";

    }

}

sub output_health_text {

    my ($fh, $health) = @_;

    print $fh "DRIVE HEALTH OVERVIEW\n";

    print $fh "-"x40 . "\n";

    foreach my $drive (@$health) {

        print $fh "$drive->{device_path}: $drive->{status}";

        print $fh " (Risk: $drive->{risk_level})" if $drive->{risk_level};

        print $fh "\n";

    }

}

sub output_alerts_text {

    my ($fh, $alerts) = @_;

    print $fh "ALERT HISTORY\n";

    print $fh "-"x40 . "\n";

    foreach my $alert (@$alerts) {

        printf $fh "%s [%s] %s: %s\n",

            $alert->{sent_at},

            $alert->{alert_type},

            $alert->{device_path},

            $alert->{message} || '';

    }

}

sub output_trends_text {

    my ($fh, $trends) = @_;

    print $fh "TREND ANALYSIS\n";

    print $fh "-"x40 . "\n";

    foreach my $device (sort keys %$trends) {

        print $fh "Device: $device\n";

        foreach my $trend (@{$trends->{$device}}) {

            print $fh "  $trend->{date}: Temp $trend->{avg_temp}°C ($trend->{reading_count} readings)\n";

        }

        print $fh "\n";

    }

}

=head2 print_help

Display help information

=cut

sub print_help {

    print <<'EOF';

autoSMART Report Generator v1.0

USAGE:

    autosmart-report.pl [OPTIONS]

OPTIONS:

    --config-dir DIR     Configuration directory (default: /etc/autosmart)

    --report TYPE        Report type (default: summary)

                         summary   - System overview and statistics

                         detailed  - Detailed drive information

                         health    - Current health status of all drives

                         alerts    - Alert history

                         trends    - Trend analysis

    --device PATH        Generate report for specific device only

    --days N            Days of history to include (default: 30)

    --format FORMAT     Output format: text, html, json (default: text)

    --output FILE       Write to file instead of stdout

    --help              Show this help message

EXAMPLES:

    # System summary

    autosmart-report.pl --report summary

    # Detailed report for specific drive

    autosmart-report.pl --report detailed --device /dev/sda

    # Health status as HTML

    autosmart-report.pl --report health --format html --output health.html

    # Alert history for last week

    autosmart-report.pl --report alerts --days 7

    # Trend analysis as JSON

    autosmart-report.pl --report trends --format json

REPORT TYPES:

    summary     High-level system statistics and overview

    detailed    Comprehensive information about each drive

    health      Current health status summary

    alerts      Recent alerts and notifications

    trends      Temperature and performance trends

OUTPUT FORMATS:

    text        Human-readable text format (default)

    html        HTML report with basic styling

    json        Machine-readable JSON format

EOF

}

__END__

=head1 AUTHOR

AutoSMART Development Team

=head1 LICENSE

This software is part of the autoSMART project.

=cut