#!/bin/bash

ffoo import inigrep
ffoo import pretty


__saturnin_urimagic__filter_exprs() {
    #
    # Hack expressions like bug = 123 out of the text
    #
    sed -e 's/(\d)\</\n/;'\
      | perl -ne '
            next unless m/\b([a-zA-Z]\w*\s*=\s*\w+)\b/;
            print "$1\n";
        '
}


__saturnin_urimagic__filter_ids() {
    #
    # Hack doer-like id's (ID#123) out of the text
    #
    tr ' ' '\n' \
      | perl -ne '
            next unless m/\b([a-zA-Z]\w*#\w+)\b/;
            print "$1\n";
        '
}


__saturnin_urimagic__filter_tags() {
    #
    # Hack "tags" like bug123 out of the text
    #
    tr ' ' '\n' \
      | grep -E '^[a-zA-Z]+[0-9]+$'
}


__saturnin_urimagic__filter_kws() {
    #
    # Hack out lines that look like kw expressions
    #
    grep -Ee '^[a-zA-Z]\w*\s+[^=]' -e '^[a-zA-Z]\w*$'
}


__saturnin_urimagic__filter_uris() {
    #
    # Hack URIs out of the text.
    #
    tr ' ' '\n' \
      | perl -ne '
            next unless m|(\bhttps?://[[:alnum:]_:/.?#&+,%@=;~-]+)\b|;
            print "$1\n";
        '
}


saturnin_urimagic__scan() {
    #
    # Scan stdin for what looks like URI, ID or keyword
    #
    # Output URIs: first what were apparent uris, then IDs converted to
    # URIs, then equal sign expressions, then "tags" like bug1234 (i.e.
    # letters+nubmbers, no spaces), then things that looked like
    # kw expressions, converted to URIs.
    #
    # Note that kw expressions (e.g. "bug 123") work only if they start
    # the line.
    #
    # Apply this filter to args or clipboard, and either use head -1 or
    # if you are brave, open all URIs.
    #
    local d=$(mktemp -d -t saturnin_urimagic.XXXXXXXX)
    local p=__saturnin_urimagic__
    pushd $d >&/dev/null
        ##
        # heat up and fill pipes
        #
        mkfifo maybe_uris maybe_ids maybe_exprs maybe_tags maybe_kws \
               uris uris_from_ids uris_from_exprs uris_from_tags uris_from_kws
        cat | tee maybe_uris maybe_ids maybe_exprs maybe_tags maybe_kws >/dev/null &
        ##
        # process each pipe *async* by different filter
        #
        < maybe_uris  ${p}filter_uris                     > uris &
        < maybe_ids   ${p}filter_ids   | ${p}id2kw   | ${p}kw2uri > uris_from_ids &
        < maybe_exprs ${p}filter_exprs | ${p}expr2kw | ${p}kw2uri > uris_from_exprs &
        < maybe_tags  ${p}filter_tags  | ${p}tag2kw  | ${p}kw2uri > uris_from_tags &
        < maybe_kws   ${p}filter_kws   |               ${p}kw2uri > uris_from_kws &
        ##
        # print result *sync* in correct order
        #
        {
            cat uris
            cat uris_from_ids
            cat uris_from_exprs
            cat uris_from_tags
            cat uris_from_kws
        } | grep .  # throw away empties; add missing LF
    popd >&/dev/null
    rm -rf $d
}


__saturnin_urimagic__id2kw() {
    #
    # Convert doer-like ID to kw expression
    #
    tr '#' ' '
}


__saturnin_urimagic__tag2kw() {
    #
    # Convert tag to kw expression
    #
    sed -r 's/([a-zA-Z]+)([0-9])/\1 \2/'
}


__saturnin_urimagic__expr2kw() {
    #
    # Convert equal sign expression to kw expression
    #
    sed -re 's/\s*=\s*/ /' | tr '[:upper:]' '[:lower:]'
}


__saturnin_urimagic__kw2uri() {
    #
    # Turn keyword or query (like "g hello" for google) to URI
    #
    local line      # input line,   eg. "g hello dolly" or "bug 1234"
    local kw        # keyword part, eg. "g"             or "bug"
    local query     # query part,   eg. "hello dolly"   or "1234"
    while read line;
    do
        line="$line "
        kw=${line%% *}
        query=${line#$kw }
        debug -v kw query
        if test -n "$query";
        then
            local fmt=$(inigrep -j -1 -p www.query.${kw,,})
            debug -v fmt
            printf "$fmt\n" "$query"
        else
            inigrep -j -1 -p www.bookmark.$kw
        fi
    done
}