#!/usr/bin/perl

use strict;
use warnings;
use Storable qw(retrieve);
use Encode qw(decode_utf8 encode_utf8);
use URI::Escape qw(uri_unescape);
use HTML::Escape qw(escape_html);

# Configuration
my $max_parallel   = 50;                    # Max parallel search requests
my $lock_timeout   = 30;                    # Seconds before dropping stale locks
my $max_results    = 20;                    # Max search results to display
my $sa_file        = 'sa.bin';              # Suffix Array index
my $cp_file        = 'corpus.bin';          # Raw text corpus
my $map_file       = 'file_map.dat';        # File metadata
my $lock_dir       = '/tmp/search_locks';   # Semaphore directory

# Concurrency control
mkdir $lock_dir, 0777 unless -d $lock_dir;
my $active_count = 0;
my $now = time();

opendir(my $dh, $lock_dir);
while (my $file = readdir($dh)) {
    next unless $file =~ /\.lock$/;
    my $path = "$lock_dir/$file";
    my $mtime = (stat($path))[9] || 0;
    ($now - $mtime > $lock_timeout) ? unlink($path) : $active_count++;
}
closedir($dh);

# Template variables
my $year = (localtime)[5] + 1900;
my $search_text = '';

# Busy check
if ($active_count >= $max_parallel) {
    print "Content-Type: text/html\n\n";
    render_html("<p>Server busy. Please try again in a few seconds.</p>", "", $year);
    exit;
}

# Create semaphore lock
my $lock_file = "$lock_dir/$$.lock";
open(my $fh_lock, '>', $lock_file);

# Query decoding
if (($ENV{QUERY_STRING} || '') =~ /^q=([^&]*)/) {
    my $raw_q = $1;
    $raw_q =~ tr/+/ /;
    $search_text = uri_unescape($raw_q);
    $search_text = decode_utf8($search_text // "");
    $search_text =~ s/\P{Print}//g; 
    $search_text = substr($search_text, 0, 64);
    $search_text =~ s/^\s+|\s+$//g;
}

my $safe_search_text = escape_html($search_text);

print "Content-Type: text/html\n\n";

if ($search_text eq '') {
    final_output("<p>Please enter a search term above.</p>");
}

# Binary search 
my @results;
my $query = encode_utf8(lc($search_text));
my $query_len = length($query);

if (-f $sa_file && -f $cp_file) {
    open(my $fh_sa, '<', $sa_file) or die $!;
    open(my $fh_cp, '<', $cp_file) or die $!;
    binmode($fh_sa);
    binmode($fh_cp);

    my $file_map = retrieve($map_file);
    my $total_suffixes = (-s $sa_file) / 4;

    # Find left boundary
    my ($low, $high) = (0, $total_suffixes - 1);
    my $first_hit = -1;

    while ($low <= $high) {
        my $mid = int(($low + $high) / 2);
        seek($fh_sa, $mid * 4, 0);
        read($fh_sa, my $bin_off, 4);
        my $off = unpack("L", $bin_off);
        seek($fh_cp, $off, 0);
        read($fh_cp, my $text, $query_len);
        
        my $cmp = $text cmp $query;
        if ($cmp >= 0) {
            $first_hit = $mid if $cmp == 0;
            $high = $mid - 1;
        } else {
            $low = $mid + 1;
        }
    }

    # Collect results if found
    if ($first_hit != -1) {
        my $last_hit = $first_hit;
        ($low, $high) = ($first_hit, $total_suffixes - 1);
        
        # Find right boundary
        while ($low <= $high) {
            my $mid = int(($low + $high) / 2);
            seek($fh_sa, $mid * 4, 0);
            read($fh_sa, my $bin_off, 4);
            my $off = unpack("L", $bin_off);
            seek($fh_cp, $off, 0);
            read($fh_cp, my $text, $query_len);
            
            if (($text cmp $query) <= 0) {
                $last_hit = $mid if $text eq $query;
                $low = $mid + 1;
            } else {
                $high = $mid - 1;
            }
        }

        my %seen;
        for my $i ($first_hit .. $last_hit) {
            seek($fh_sa, $i * 4, 0);
            read($fh_sa, my $bin_off, 4);
            my $offset = unpack("L", $bin_off);

            foreach my $m (@$file_map) {
                if ($offset >= $m->{start} && $offset < $m->{end}) {
                    if (!$seen{$m->{path}}++) {
                        # Capture more than 50 chars for trimming
                        my $snip_start = ($offset - 30 < $m->{start}) ? $m->{start} : $offset - 30;
                        my $max_len = $m->{end} - $snip_start;
                        my $read_len = ($max_len > 120) ? 120 : $max_len;
                        seek($fh_cp, $snip_start, 0);
                        read($fh_cp, my $raw_snip, $read_len);
                        
                        my $snippet = decode_utf8($raw_snip, Encode::FB_QUIET) // $raw_snip;
                        $snippet =~ s/\s+/ /g; # Normalize whitespace

                        # Trim start: Partial word removal
                        if ($snip_start > $m->{start}) {
                            $snippet =~ s/^[^\s]*\s//; 
                        }

                        # Trim end: Length limit and partial word removal
                        my $has_more = 0;
                        if (length($snippet) > 50) {
                            $snippet = substr($snippet, 0, 50);
                            $has_more = 1 if $snippet =~ s/\s+[^\s]*$//;
                        }
                        elsif ($snip_start + $read_len < $m->{end}) {
                            # This check handles snippets that are naturally short but 
                            # there's still more text in the article we didn't read
                            $has_more = 1; 
                        }

                        # Cleanup & capitalize
                        $snippet = ucfirst($snippet);
                        $snippet = escape_html($snippet) . ($has_more ? "..." : "");

                        my $clean_path = $m->{path};
                        $clean_path =~ s|^\.\./_site/||;

                        push @results, {
                            path    => $clean_path,
                            title   => $m->{title},,
                            snippet => $snippet
                        };
                    }
                    last;
                }
            }
            last if scalar @results >= $max_results;
        }
    }
    close($fh_sa);
    close($fh_cp);
}

# --- Formatting & Output ---
my $list_html = "";
if (@results == 0) {
    $list_html = "<p>No results found for \"<b>$safe_search_text</b>\".</p>";
} else {
    $list_html = "<ul>" . join('', map { 
        "<li><a href=\"/$_->{path}\">$_->{title}</a><br><small>$_->{snippet}</small></li>" 
    } @results) . "</ul>";
}

final_output($list_html);

# --- Helpers ---
sub final_output {
    my ($content) = @_;
    render_html($content, $safe_search_text, $year);
    if ($fh_lock) { close($fh_lock); unlink($lock_file); }
    exit;
}

sub render_html {
    my ($content, $q_val, $yr) = @_;
    print <<"HTML";
<!DOCTYPE html>
<html lang="en-us">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Search</title>
    <link rel="stylesheet" href="/assets/css/main.css">
    <link rel="stylesheet" href="/assets/css/skeleton.css">
</head>
<body>
    <div id="nav-container" class="container">
        <ul id="navlist" class="left">
            <li><a href="/" class="link-decor-none">hme</a></li>
            <li><a href="/log/" class="link-decor-none">log</a></li>
            <li><a href="/projects/" class="link-decor-none">poc</a></li>
            <li><a href="/about/" class="link-decor-none">abt</a></li>
            <li class="active"><a href="/cgi-bin/find.cgi" class="link-decor-none">sws</a></li>
            <li><a href="/feed.xml" class="link-decor-none">rss</a></li>
        </ul>
    </div>
    <main class="container" id="main">
        <div class="container">
            <h2>Search</h2>
            <form action="" method="GET">
                <input id="search-box" type="text" name="q" value="$q_val">
                <input id="search-btn" type="submit" value="Search">
            </form>
            $content
        </div>
    </main>
    <div class="footer">
        <div class="container">
            <div class="twelve columns right container-2">
                <p id="footer-text">&copy; ASCIIMX - $yr</p>
            </div>
        </div>
    </div>
</body>
</html>
HTML
}