#!/usr/bin/env nu

# User notification tool - sends update notifications and announcements
#
# Notifications:
# - Email notifications to subscribers
# - Slack/Discord announcements
# - Twitter/social media posts
# - RSS feed updates
# - Website banner updates
# - GitHub discussions/issues

use std log

def main [
    --channels: string = "slack"               # Notification channels: slack,discord,twitter,email,rss,website,all
    --release-version: string = ""             # Release version (auto-detected if empty)
    --message-template: string = ""            # Custom message template file
    --notification-config: string = ""         # Notification configuration file
    --recipient-list: string = ""              # Recipient list file (for email)
    --dry-run: bool = false                    # Show what would be sent without sending
    --urgent: bool = false                     # Mark notifications as urgent/high priority
    --schedule: string = ""                    # Schedule notifications (e.g., "+1h", "2024-01-15T10:00:00")
    --verbose: bool = false                    # Enable verbose logging
] -> record {

    let repo_root = ($env.PWD | path dirname | path dirname | path dirname)

    # Determine release version if not provided
    let target_version = if $release_version == "" {
        detect_release_version $repo_root
    } else {
        $release_version
    }

    let notification_channels = if $channels == "all" {
        ["slack", "discord", "twitter", "email", "rss", "website"]
    } else {
        ($channels | split row "," | each { str trim })
    }

    let notification_config = {
        channels: $notification_channels
        release_version: $target_version
        message_template_file: (if $message_template == "" { "" } else { $message_template | path expand })
        notification_config_file: (if $notification_config == "" { "" } else { $notification_config | path expand })
        recipient_list_file: (if $recipient_list == "" { "" } else { $recipient_list | path expand })
        dry_run: $dry_run
        urgent: $urgent
        schedule: $schedule
        verbose: $verbose
        repo_root: $repo_root
    }

    log info $"Starting user notifications with config: ($notification_config)"

    # Load notification configuration
    let config_data = if $notification_config.notification_config_file != "" {
        load_notification_config $notification_config.notification_config_file
    } else {
        get_default_notification_config
    }

    # Generate release information
    let release_info = generate_release_info $notification_config $repo_root

    # Load or generate message templates
    let message_templates = if $notification_config.message_template_file != "" {
        load_message_templates $notification_config.message_template_file
    } else {
        generate_default_templates $release_info
    }

    # Check if notifications should be scheduled
    if $notification_config.schedule != "" {
        return schedule_notifications $notification_config $message_templates $config_data $release_info
    }

    # Send notifications to each channel
    let notification_results = $notification_config.channels | each {|channel|
        send_notification $channel $notification_config $message_templates $config_data $release_info
    }

    let summary = {
        total_channels: ($notification_config.channels | length)
        successful_notifications: ($notification_results | where status == "success" | length)
        failed_notifications: ($notification_results | where status == "failed" | length)
        skipped_notifications: ($notification_results | where status == "skipped" | length)
        release_version: $notification_config.release_version
        notification_config: $notification_config
        results: $notification_results
    }

    if $summary.failed_notifications > 0 {
        log error $"Notifications completed with ($summary.failed_notifications) failures"
        exit 1
    } else {
        if $notification_config.dry_run {
            log info $"Dry run completed - would send notifications to ($summary.total_channels) channels"
        } else {
            log info $"Notifications sent successfully to ($summary.successful_notifications) channels"
        }
    }

    return $summary
}

# Detect release version from git
def detect_release_version [repo_root: string] -> string {
    cd $repo_root

    try {
        # Try to get exact tag for current commit
        let exact_tag = (git describe --tags --exact-match HEAD 2>/dev/null | str trim)
        if $exact_tag != "" {
            return ($exact_tag | str replace "^v" "")
        }

        # Fallback to latest tag
        let latest_tag = (git describe --tags --abbrev=0 2>/dev/null | str trim)
        if $latest_tag != "" {
            return ($latest_tag | str replace "^v" "")
        }

        return "unknown"
    } catch {
        return "unknown"
    }
}

# Load notification configuration from file
def load_notification_config [config_file: string] -> record {
    if not ($config_file | path exists) {
        log warning $"Notification config file not found: ($config_file)"
        return (get_default_notification_config)
    }

    try {
        open $config_file
    } catch {|err|
        log warning $"Failed to load notification config: ($err.msg)"
        return (get_default_notification_config)
    }
}

# Get default notification configuration
def get_default_notification_config [] -> record {
    {
        slack: {
            webhook_url: ""
            channel: "#general"
            username: "Provisioning Bot"
            icon_emoji: ":rocket:"
        }
        discord: {
            webhook_url: ""
            username: "Provisioning Bot"
            avatar_url: ""
        }
        twitter: {
            api_key: ""
            api_secret: ""
            access_token: ""
            access_token_secret: ""
        }
        email: {
            smtp_server: "smtp.gmail.com"
            smtp_port: 587
            username: ""
            password: ""
            from_address: "noreply@example.com"
            from_name: "Provisioning Team"
        }
        rss: {
            feed_file: "releases.xml"
            feed_title: "Provisioning Releases"
            feed_description: "Latest releases of the Provisioning system"
            feed_url: "https://example.com/releases.xml"
        }
        website: {
            banner_file: "release-banner.html"
            api_endpoint: ""
            api_key: ""
        }
    }
}

# Generate release information
def generate_release_info [notification_config: record, repo_root: string] -> record {
    cd $repo_root

    let version = $notification_config.release_version
    let tag_name = $"v($version)"

    # Get release date
    let release_date = try {
        git log -1 --format=%cd --date=short $tag_name 2>/dev/null | str trim
    } catch {
        date now | format date "%Y-%m-%d"
    }

    # Get changelog
    let changelog = try {
        get_changelog_summary $repo_root $tag_name
    } catch {
        "Bug fixes and improvements"
    }

    # Get download URLs
    let download_base_url = $"https://github.com/your-org/provisioning/releases/download/($tag_name)"
    let download_urls = {
        linux: $"($download_base_url)/provisioning-($version)-linux-complete.tar.gz"
        macos: $"($download_base_url)/provisioning-($version)-macos-complete.tar.gz"
        windows: $"($download_base_url)/provisioning-($version)-windows-complete.zip"
    }

    # Get release notes URL
    let release_url = $"https://github.com/your-org/provisioning/releases/tag/($tag_name)"

    {
        version: $version
        tag_name: $tag_name
        release_date: $release_date
        changelog: $changelog
        download_urls: $download_urls
        release_url: $release_url
        is_major: (is_major_version $version)
        is_security: (is_security_release $changelog)
    }
}

# Get changelog summary for a specific tag
def get_changelog_summary [repo_root: string, tag_name: string] -> string {
    # Get previous tag
    let previous_tag = try {
        git describe --tags --abbrev=0 $"($tag_name)^" 2>/dev/null | str trim
    } catch {
        ""
    }

    # Get commits between tags
    let commit_range = if $previous_tag != "" {
        $"($previous_tag)..($tag_name)"
    } else {
        $tag_name
    }

    let commits = try {
        git log $commit_range --pretty=format:"%s" --no-merges | lines | where $it != ""
    } catch {
        []
    }

    # Summarize changes
    let features = ($commits | where ($it =~ "^feat"))
    let fixes = ($commits | where ($it =~ "^fix"))
    let mut summary_parts = []

    if ($features | length) > 0 {
        $summary_parts = ($summary_parts | append $"($features | length) new features")
    }

    if ($fixes | length) > 0 {
        $summary_parts = ($summary_parts | append $"($fixes | length) bug fixes")
    }

    if ($summary_parts | length) > 0 {
        return ($summary_parts | str join ", ")
    } else {
        return "Bug fixes and improvements"
    }
}

# Check if version is a major release
def is_major_version [version: string] -> bool {
    let parts = ($version | split row ".")
    if ($parts | length) >= 3 {
        let minor = ($parts | get 1)
        let patch = ($parts | get 2)
        return ($minor == "0" and $patch == "0")
    }
    return false
}

# Check if release contains security fixes
def is_security_release [changelog: string] -> bool {
    ($changelog | str downcase | str contains "security") or
    ($changelog | str downcase | str contains "vulnerability") or
    ($changelog | str downcase | str contains "cve")
}

# Load message templates from file
def load_message_templates [template_file: string] -> record {
    if not ($template_file | path exists) {
        log warning $"Template file not found: ($template_file)"
        return {}
    }

    try {
        open $template_file
    } catch {|err|
        log warning $"Failed to load templates: ($err.msg)"
        return {}
    }
}

# Generate default message templates
def generate_default_templates [release_info: record] -> record {
    let urgency_text = if $release_info.is_security { "🚨 Security Update " } else if $release_info.is_major { "🎉 Major Release " } else { "" }
    let emoji = if $release_info.is_security { "🔒" } else if $release_info.is_major { "🎉" } else { "🚀" }

    {
        slack: {
            text: $"($urgency_text)($emoji) Provisioning v($release_info.version) Released!"
            attachments: [
                {
                    color: (if $release_info.is_security { "danger" } else { "good" })
                    fields: [
                        { title: "Version", value: $release_info.version, short: true }
                        { title: "Release Date", value: $release_info.release_date, short: true }
                        { title: "Changes", value: $release_info.changelog, short: false }
                    ]
                    actions: [
                        { type: "button", text: "Download", url: $release_info.download_urls.linux }
                        { type: "button", text: "Release Notes", url: $release_info.release_url }
                    ]
                }
            ]
        }
        discord: {
            content: $"($urgency_text)($emoji) **Provisioning v($release_info.version)** has been released!"
            embeds: [
                {
                    title: $"Release v($release_info.version)"
                    description: $release_info.changelog
                    color: (if $release_info.is_security { 15158332 } else { 3066993 })  # Red or Green
                    fields: [
                        { name: "Release Date", value: $release_info.release_date, inline: true }
                        { name: "Downloads", value: $"[Linux]((\"($release_info.download_urls.linux)\")) | [macOS]((\"($release_info.download_urls.macos)\")) | [Windows]((\"($release_info.download_urls.windows)\"))", inline: false }
                    ]
                    url: $release_info.release_url
                    timestamp: (date now | format date "%Y-%m-%dT%H:%M:%S.000Z")
                }
            ]
        }
        twitter: {
            status: $"($urgency_text)($emoji) Provisioning v($release_info.version) is now available! ($release_info.changelog) Download: ($release_info.release_url) #CloudNative #Infrastructure #DevOps"
        }
        email: {
            subject: $"($urgency_text)Provisioning v($release_info.version) Released"
            body: $"Dear Provisioning Users,

We're excited to announce the release of Provisioning v($release_info.version)!

**What's New:**
($release_info.changelog)

**Downloads:**
- Linux: ($release_info.download_urls.linux)
- macOS: ($release_info.download_urls.macos)
- Windows: ($release_info.download_urls.windows)

**Release Notes:**
For detailed information about this release, please visit:
($release_info.release_url)

Thank you for using Provisioning!

Best regards,
The Provisioning Team"
        }
    }
}

# Schedule notifications for later
def schedule_notifications [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info $"Scheduling notifications for: ($notification_config.schedule)"

    # In a real implementation, this would use a job scheduler like cron
    # For now, we'll just return the scheduled job information

    {
        status: "scheduled"
        schedule_time: $notification_config.schedule
        channels: $notification_config.channels
        release_version: $notification_config.release_version
        message: "Notifications scheduled successfully"
    }
}

# Send notification to specific channel
def send_notification [
    channel: string
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info $"Sending notification to: ($channel)"

    let start_time = (date now)

    match $channel {
        "slack" => { send_slack_notification $notification_config $message_templates $config_data $release_info }
        "discord" => { send_discord_notification $notification_config $message_templates $config_data $release_info }
        "twitter" => { send_twitter_notification $notification_config $message_templates $config_data $release_info }
        "email" => { send_email_notification $notification_config $message_templates $config_data $release_info }
        "rss" => { update_rss_feed $notification_config $message_templates $config_data $release_info }
        "website" => { update_website_banner $notification_config $message_templates $config_data $release_info }
        _ => {
            log warning $"Unknown notification channel: ($channel)"
            {
                channel: $channel
                status: "failed"
                reason: "unknown channel"
                duration: ((date now) - $start_time)
            }
        }
    }
}

# Send Slack notification
def send_slack_notification [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Sending Slack notification..."

    let start_time = (date now)
    let slack_config = ($config_data.slack)

    if $slack_config.webhook_url == "" {
        return {
            channel: "slack"
            status: "failed"
            reason: "webhook URL not configured"
            duration: ((date now) - $start_time)
        }
    }

    if $notification_config.dry_run {
        return {
            channel: "slack"
            status: "success"
            message_preview: $message_templates.slack.text
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    try {
        let payload = {
            channel: $slack_config.channel
            username: $slack_config.username
            icon_emoji: $slack_config.icon_emoji
            text: $message_templates.slack.text
            attachments: $message_templates.slack.attachments
        }

        let curl_result = (curl -X POST -H "Content-type: application/json" --data ($payload | to json) $slack_config.webhook_url | complete)

        if $curl_result.exit_code == 0 {
            {
                channel: "slack"
                status: "success"
                webhook_url: $slack_config.webhook_url
                duration: ((date now) - $start_time)
            }
        } else {
            {
                channel: "slack"
                status: "failed"
                reason: $curl_result.stderr
                duration: ((date now) - $start_time)
            }
        }

    } catch {|err|
        {
            channel: "slack"
            status: "failed"
            reason: $err.msg
            duration: ((date now) - $start_time)
        }
    }
}

# Send Discord notification
def send_discord_notification [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Sending Discord notification..."

    let start_time = (date now)
    let discord_config = ($config_data.discord)

    if $discord_config.webhook_url == "" {
        return {
            channel: "discord"
            status: "failed"
            reason: "webhook URL not configured"
            duration: ((date now) - $start_time)
        }
    }

    if $notification_config.dry_run {
        return {
            channel: "discord"
            status: "success"
            message_preview: $message_templates.discord.content
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    try {
        let payload = {
            username: $discord_config.username
            avatar_url: $discord_config.avatar_url
            content: $message_templates.discord.content
            embeds: $message_templates.discord.embeds
        }

        let curl_result = (curl -X POST -H "Content-type: application/json" --data ($payload | to json) $discord_config.webhook_url | complete)

        if $curl_result.exit_code == 0 {
            {
                channel: "discord"
                status: "success"
                webhook_url: $discord_config.webhook_url
                duration: ((date now) - $start_time)
            }
        } else {
            {
                channel: "discord"
                status: "failed"
                reason: $curl_result.stderr
                duration: ((date now) - $start_time)
            }
        }

    } catch {|err|
        {
            channel: "discord"
            status: "failed"
            reason: $err.msg
            duration: ((date now) - $start_time)
        }
    }
}

# Send Twitter notification
def send_twitter_notification [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Sending Twitter notification..."

    let start_time = (date now)

    if $notification_config.dry_run {
        return {
            channel: "twitter"
            status: "success"
            tweet_preview: $message_templates.twitter.status
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    # Twitter API integration would be implemented here
    log warning "Twitter notification not fully implemented - requires API setup"

    {
        channel: "twitter"
        status: "skipped"
        reason: "not fully implemented"
        duration: ((date now) - $start_time)
    }
}

# Send email notification
def send_email_notification [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Sending email notification..."

    let start_time = (date now)

    if $notification_config.dry_run {
        return {
            channel: "email"
            status: "success"
            subject_preview: $message_templates.email.subject
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    # Email sending would be implemented here using SMTP
    log warning "Email notification not fully implemented - requires SMTP configuration"

    {
        channel: "email"
        status: "skipped"
        reason: "not fully implemented"
        duration: ((date now) - $start_time)
    }
}

# Update RSS feed
def update_rss_feed [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Updating RSS feed..."

    let start_time = (date now)
    let rss_config = ($config_data.rss)

    if $notification_config.dry_run {
        return {
            channel: "rss"
            status: "success"
            feed_file: $rss_config.feed_file
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    try {
        let rss_item = generate_rss_item $release_info
        # RSS feed update logic would be implemented here
        log warning "RSS feed update not fully implemented"

        {
            channel: "rss"
            status: "skipped"
            reason: "not fully implemented"
            feed_file: $rss_config.feed_file
            duration: ((date now) - $start_time)
        }

    } catch {|err|
        {
            channel: "rss"
            status: "failed"
            reason: $err.msg
            duration: ((date now) - $start_time)
        }
    }
}

# Update website banner
def update_website_banner [
    notification_config: record
    message_templates: record
    config_data: record
    release_info: record
] -> record {
    log info "Updating website banner..."

    let start_time = (date now)

    if $notification_config.dry_run {
        return {
            channel: "website"
            status: "success"
            dry_run: true
            duration: ((date now) - $start_time)
        }
    }

    # Website banner update logic would be implemented here
    log warning "Website banner update not fully implemented"

    {
        channel: "website"
        status: "skipped"
        reason: "not fully implemented"
        duration: ((date now) - $start_time)
    }
}

# Generate RSS item for release
def generate_rss_item [release_info: record] -> string {
    $"<item>
    <title>Provisioning v($release_info.version) Released</title>
    <description>($release_info.changelog)</description>
    <link>($release_info.release_url)</link>
    <guid>($release_info.release_url)</guid>
    <pubDate>(date now | format date "%a, %d %b %Y %H:%M:%S %z")</pubDate>
  </item>"
}

# Show notification status
def "main status" [] {
    let curl_available = (try { curl --version | complete } catch { { exit_code: 1 } }).exit_code == 0

    let repo_root = ($env.PWD | path dirname | path dirname | path dirname)
    let current_version = (detect_release_version $repo_root)

    {
        current_version: $current_version
        available_tools: {
            curl: $curl_available
        }
        supported_channels: ["slack", "discord", "twitter", "email", "rss", "website"]
        implemented_channels: ["slack", "discord"]  # Only these are fully implemented
    }
}

# Initialize notification configuration
def "main init-config" [output_file: string = "notification-config.toml"] {
    let config_template = $"# Notification Configuration

[slack]
webhook_url = \"\"  # Your Slack webhook URL
channel = \"#general\"
username = \"Provisioning Bot\"
icon_emoji = \":rocket:\"

[discord]
webhook_url = \"\"  # Your Discord webhook URL
username = \"Provisioning Bot\"
avatar_url = \"\"

[twitter]
api_key = \"\"
api_secret = \"\"
access_token = \"\"
access_token_secret = \"\"

[email]
smtp_server = \"smtp.gmail.com\"
smtp_port = 587
username = \"\"
password = \"\"
from_address = \"noreply@example.com\"
from_name = \"Provisioning Team\"

[rss]
feed_file = \"releases.xml\"
feed_title = \"Provisioning Releases\"
feed_description = \"Latest releases of the Provisioning system\"
feed_url = \"https://example.com/releases.xml\"

[website]
banner_file = \"release-banner.html\"
api_endpoint = \"\"
api_key = \"\"
"

    $config_template | save $output_file
    log info $"Generated notification configuration template: ($output_file)"

    {
        config_file: $output_file
        channels_configured: 6
        template_generated: true
    }
}

# Test notification to specific channel
def "main test" [
    channel: string = "slack"                  # Channel to test
    --config: string = ""                      # Configuration file
] {
    log info $"Testing notification to: ($channel)"

    let test_release_info = {
        version: "1.0.0-test"
        tag_name: "v1.0.0-test"
        release_date: (date now | format date "%Y-%m-%d")
        changelog: "Test notification"
        download_urls: {
            linux: "https://example.com/linux.tar.gz"
            macos: "https://example.com/macos.tar.gz"
            windows: "https://example.com/windows.zip"
        }
        release_url: "https://github.com/example/test"
        is_major: false
        is_security: false
    }

    let test_config = {
        channels: [$channel]
        release_version: "1.0.0-test"
        dry_run: false
        verbose: true
    }

    let config_data = if $config != "" {
        load_notification_config $config
    } else {
        get_default_notification_config
    }

    let templates = generate_default_templates $test_release_info

    send_notification $channel $test_config $templates $config_data $test_release_info
}