aircon/aircon.sh

#!/bin/bash

# TODO:  comparison to previous reading
# TODO:  gnuplot of given time range
# TODO:  manual controls

DEFAULT_KILLFILE="${HOME}/.aircon_noaction"
DEFAULT_CONFIGFILE=${HOME}/.airconrc
DEFAULT_CSVFILE=${HOME}/acstats.csv
DEFAULT_AIRCON_IP=10.99.99.1
DEFAULTLIMIT=3
DEFAULT_TOLERANCE=0
VALID_MODES=" cool heat "
VALID_ZONE_STATES=" open close "

ARPING_DEF=/usr/local/sbin/arping
ARPING=${ARPING_DEF}

BOLD="\033[1m"
PLAIN="\033[0m"
STRIKE="\033[9m"
UNDERLINE="\033[4m"
DARKGREY="\033[38;2;90;90;90m"
RED="\033[31m"
ORANGE="\033[38;2;255;165;0m"
PINK="\033[38;2;255;151;198m"
MAGENTA="\033[35m"
GREEN="\033[32m"
YELLOW="\033[33m"
BLUE="\033[34m"
CYAN="\033[36m"
GREY="\033[2;37m"
WHITE="\033[37m"
LINK="$BLUE$UNDERLINE"

RULEDB=0

export PYTHONWARNINGS="ignore" # for urllib NotOpenSSLWarning

function enable_cronmode() {
    cronmode=1
    BOLD=""
    PLAIN=""
    UNDERLINE=""
    GREY=""
    RED=""
    GREEN=""
    YELLOW=""
    BLUE=""
    CYAN=""
    WHITE=""
    LINK="$BLUE$UNDERLINE"
}

function usage() {
    echo "usage:  $0 [options]"
    echo
    echo "    Modifies aircon based on configured parameters in $DEFAULT_CONFIGFILE."
    echo
    echo "    -a file       Specify location of arping binary (default: $ARPING_DEF)."
    echo "    -b            Rule debug mode.  Show processing of time rules."
    echo "    -A db         Log actions to given influxdb database."
    echo "    -c            Cron mode.  Only show output if actions were taken."
    echo "    -D dbhost     Specify influxdb hostname for -I and -A options (default: localhost)"
    echo "    -e file       After removing expired killfile, write exptext (see -E) to this file."
    echo "    -E exptext    Define 'exptext' for -e option."
    echo "    -g file       Send Tele(g)ram notifications via api.telegran.org.   File format is:"
    echo "                   bottoken"
    echo "                   chatid"
    echo "    -f file     Specify an alternate config file."
    echo "    -F zonename:temp   Forcibly provide current zone temperature (for testing)"
    echo "    -h          Show this text."
    echo "    -i x.x.x.x  Specify IP address for aircon (default is $DEFAULT_AIRCON_IP)"
    echo "    -I db       Log all zone temperatures to given influxdb database, then exit (see -o)."
    echo "    -k file     If file exists and is empty, never change aircon settings (default: $DEFAULT_KILLFILE)."
    echo "                If file is non-empty, never change aircon settings if current unixtime < file contents."
    echo "                File will be removed if current unixtime >= file contents."
    echo "    -l num      Set number of too hot/cold zones at which to taking action."
    echo "    -L          Log all zone temperatures to CSV file, then exit (see -o)."
    echo "    -m          Generate a config file based on current aircon setup."
    echo "    -o file     Specify CSV output file.  Default:  $DEFAULT_CSVFILE"
    echo "    -p          Profiler mode."
    echo "    -s          Validate config file then exit."
    echo "    -S[H]       Show configured rules in human-readable format"
    echo "                (HTML if -H given, otherwise ANSI)."
    echo "    -t num      Specify degrees below min temperature before taking action."
    echo "    -T num      Specify degrees above max temperature before taking action."
    echo "    -w          List which people are available then exit."
    echo "    -W          List zone-owning devices are available then exit."
    echo "    -y          Actually run commands/db inserts.  By default, commands are just displayed."
    echo
}

function action() {
    echo -e "$BOLD$GREEN>> Running action: $PLAIN$GREEN$*$PLAIN"
}

function warn() {
    echo -e "$BOLD${YELLOW}Warning:  $PLAIN$YELLOW$*$PLAIN" >/dev/stderr
}

function error() {
    echo -e "$BOLD${RED}ERROR:  $PLAIN$RED$*$PLAIN" >/dev/stderr
}

function info() {
    echo -e "$BOLD${CYAN}>> $PLAIN$CYAN$*$PLAIN"
}

# get_midrange zone_idx
function get_midrange() {  # outputs midpoint of temperature range for given zone
    local min max
    min=${zwantmin[$idx]}
    max=${zwantmax[$idx]}
    echo "($min + $max) / 2" | bc
}

# get_perfect_tolerance zone_idx
function get_perfect_tolerance() {  # outputs the difference from midpoint after which temperature is considered "perfect"
    local min max
    min=${zwantmin[$idx]}
    max=${zwantmax[$idx]}
    echo "scale=2; ($max - $min) / 4" | bc
}

function getoppositestate() {
    if [[ $1 == "open" ]]; then
        echo "close"
    elif [[ $1 == "close" ]]; then
        echo "open"
    fi
}

function getzoneaction() { # populates zproblem[] and zaction[]
    local idx problem num thisaction priority pingok fv
    local donearby thisperfect=0
    idx=$1

    profile "getzoneaction for idx ${zname[$idx]}"
    [[ $robtest -eq 1 ]] && echo "getzoneaction zone ${zname[$idx]}"
    thisaction="n/a"
    if [[ ${zignore[$idx]} -eq 1 ]]; then
        problem="n/a"
        thisperfect=1
    else
            [[ $robtest -eq 1 ]] && echo "    owner of ${zname[$idx]} is [${zowner[$idx]}]" >&2
        if [[ -z ${zowner[$idx]} ]]; then
            pingok=1
            #[[ $robtest -eq 1 ]] && echo "    empty owner so no ping "
        elif canping ${zowner[$idx]}; then
            #[[ $robtest -eq 1 ]] && echo "    canping returned ok"
            pingok=1
        else
            #[[ $robtest -eq 1 ]] && echo "    canping returned fail"
            pingok=0
            thisperfect=0
        fi
        fv=$(getforcevent ${zname[$idx]})
        [[ $robtest -eq 1 ]] && echo "    canping zone ${zname[$idx]} is:  $pingok"

        donearby=0

        if [[ -n $fv && ${zstate[$idx]} == $(getoppositestate ${fv}) ]]; then
            problem="force_${fv}"
            priority=99
        elif [[ $airconmode != "off" && ${zstate[$idx]} != "close" && $pingok -eq 0 ]]; then
            problem="owner_not_home"
            priority=99
        elif [[ $pingok -eq 1 && $(echo "${ztemp[$idx]} > (${zwantmax[$idx]} + $tolerance_h)" | bc) -eq 1 ]]; then
            problem="too_hot"
            priority=$(echo "${ztemp[$idx]} - ${zwantmax[$idx]}" | bc)
            if [[ $(echo "${ztemp[$idx]} > (${zwantmax[$idx]} + ($tolerance_h * 2))" | bc) -eq 1 ]]; then
                donearby=1
            fi
        elif [[ $pingok -eq 1 && $(echo "${ztemp[$idx]} < (${zwantmin[$idx]} - $tolerance_l)" | bc) -eq 1 ]]; then
            problem="too_cold"
            priority=$(echo "${zwantmin[$idx]} - ${ztemp[$idx]}" | bc)
            if [[ $(echo "${ztemp[$idx]} < (${zwantmin[$idx]} - ($tolerance_l * 2))" | bc) -eq 1 ]]; then
                donearby=1
            fi
        else
            problem="n/a"
            priority=0
        if [[ $pingok -eq 1 ]]; then
        # check for 'perfect' zones
        if [[ ${zwanttemp[$idx]} != *-* ]]; then
            thisperfect=1
        else
            local mid midtol
            mid=$(get_midrange $idx)
            midtol=$(get_perfect_tolerance $idx)
            #echo "zone ${zname[$idx]} temp ${ztemp[$idx]} mid is $mid   midtol is $midtol perfect is >= $(echo "$mid - $midtol" | bc)"
            if [[ $airconmode == "heat" ]]; then
                thisperfect=$(echo "${ztemp[$idx]} >= (${mid} + ${midtol})" | bc)
            elif [[ $airconmode == "cool" ]]; then
                thisperfect=$(echo "${ztemp[$idx]} <= (${mid} - ${midtol})" | bc)
            fi
            fi
        fi
        fi
        zproblem[$idx]="$problem"
        zpri[$idx]="$priority"
        zownerhome[$idx]="$pingok"

        [[ $robtest -eq 1 ]] && echo "    zproblem is:  ${zproblem[$idx]}"
        [[ $robtest -eq 1 ]] && echo "    zpri is:  ${zpri[$idx]}"
        [[ $robtest -eq 1 ]] && echo "    zownerhome is:  ${zownerhome[$idx]}"


        if [[ $problem == "owner_not_home" ]]; then
            # turn the zone off
            if [[ ${zstate[$idx]} != "close" ]]; then
                thisaction="$thisaction close_vent"
            fi
        elif [[ $problem =~ force_ ]]; then
            if [[ ${zstate[$idx]} != $fv ]]; then
                thisaction="$thisaction ${fv}_vent"
            fi
        elif [[ $problem == "too_cold" ]]; then
            if [[ $airconmode == "heat" || $airconmode == "off" ]]; then
                # turn the system on, if required
                if [[ $airconmode == "off" ]]; then
                    if [[ $modelock == "n/a" || $modelock == "heat" ]]; then
                        thisaction="$thisaction power_on set_mode:heat"
                    fi
                fi

                # if we couldnt turn the system on, there's nothing else to do
                if [[ $airconmode == "heat" || $thisaction == *set_mode:heat* ]]; then
                    # adjust set temperature, if required
                    if [[ $(echo "${zsettemp[$idx]} > ${zwantmax[$idx]}" | bc) -eq 1 || $(echo "${zsettemp[$idx]} < ${zwantmin[$idx]}" | bc) -eq 1 ]]; then
                        # set temperature to midpoint of acceptable range
                        num=$(get_midrange $idx)
                        if [[ $zsettemp != $num ]]; then
                            thisaction="$thisaction set_temp:$num"
                        fi
                    fi
                    # open the vent, if required
                    if [[ ${zstate[$idx]} != "open" ]]; then
                        thisaction="$thisaction open_vent"
                    fi
                    # set myzone, even if not required (will fix later)
                    thisaction="$thisaction set_myzone"
                fi
            elif [[ $airconmode == "cool" ]]; then
                # set temperature to midpoint of acceptable range
                num=$(get_midrange $idx)
                if [[ $zsettemp != $num ]]; then
                    thisaction="$thisaction set_temp:$num"
                fi
                # close the vent, if required
                if [[ ${zstate[$idx]} != "close" ]]; then
                    thisaction="$thisaction close_vent"
                elif [[ $donearby -eq 1 ]]; then
                    thisaction="close_nearby_zone"
                fi
            fi
        elif [[ $problem == "too_hot" ]]; then
            if [[ $airconmode == "cool" || $airconmode == "off" ]]; then
                # turn the system on, if required
                if [[ $airconmode == "off" ]]; then
                    if [[ $modelock == "n/a" || $modelock == "cool" ]]; then
                        thisaction="$thisaction power_on set_mode:cool"
                    fi
                fi

                # if we couldnt turn the system on, there's nothing else to do
                if [[ $airconmode == "cool" || $thisaction == *set_mode:cool* ]]; then
                    # adjust set temperature, if required
                    if [[ $(echo "${zsettemp[$idx]} > ${zwantmax[$idx]}" | bc) -eq 1 || $(echo "${zsettemp[$idx]} < ${zwantmin[$idx]}" | bc) -eq 1 ]]; then
                        # set temperature to midpoint of acceptable range
                        num=$(get_midrange $idx)
                        if [[ $zsettemp != $num ]]; then
                            thisaction="$thisaction set_temp:$num"
                        fi
                    fi
                    # open the vent, if required
                    if [[ ${zstate[$idx]} != "open" ]]; then
                        thisaction="$thisaction open_vent"
                    fi
                    # set myzone, even if not required (will fix later)
                    thisaction="$thisaction set_myzone"
                fi
            elif [[ $airconmode == "heat" ]]; then
                # set temperature to midpoint of acceptable range
                num=$(get_midrange $idx)
                if [[ $zsettemp != $num ]]; then
                    thisaction="$thisaction set_temp:$num"
                fi
                # close the vent, if required
                if [[ ${zstate[$idx]} != "close" ]]; then
                    thisaction="$thisaction close_vent"
                elif [[ $donearby -eq 1 ]]; then
                    thisaction="close_nearby_zone"
                fi
            fi
        fi
    fi
    zaction[$idx]="$thisaction"
    zperfect[$idx]=$thisperfect
    [[ $robtest -eq 1 ]] && echo "    zaction is:  ${zaction[$idx]}"
    [[ $robtest -eq 1 ]] && echo "    zperfect is:  ${zperfect[$idx]}"
    profile "getzoneaction for idx ${zname[$idx]}"
}

function getidxfromname() { #  name
    local x
#echo "==== getidxfromname($1)" >/dev/stderr
    for x in ${!zname[@]}; do
#echo "==== idx $x  comparing zname ('${zname[$x]}') to \$1 ('$1')" >/dev/stderr
        if [[ ${zname[$x]} == "$1" ]]; then
#echo "       ==== matched. returning ${x}" >/dev/stderr
            echo "${x}"
            return
        fi
    done
    echo "-1"
}

function getnamefromid() { #  id
    local x
    for x in ${!zname[@]}; do
        if [[ ${zid[$x]} == $1 ]]; then
            echo "${zname[$x]}"
        fi
    done
}

# getforcevent zone_name
function getforcevent() {
    local x retval
    retval=""
    for x in ${!fv_zonename[@]}; do
        if [[ ${fv_zonename[$x]} == "$1" ]]; then
            retval="${fv_state[$x]}"
            break
        fi
    done
    echo "$retval"
}

# getalladj zone_name
function getalladj() {
    local x retval
    retval=""
    for x in ${!adj_zonename[@]}; do
        if [[ ${adj_zonename[$x]} == "$1" ]]; then
            retval="${adj_nearby[$x]}"
            break
        fi
    done
    echo "$retval"
}

function find_nearby_zones() {  # zone_idx filter1 filter2 ...     filter is:  open|closed|noaction
    local idx thiszone nearbyzones allnearbyzones thisone zi ok db conditions
    idx=$1
    shift
    conditions="$*"
    db=0
    if [[ $db -eq 1 ]]; then
        echo "find_nearby_zones():  idx = $idx" >/dev/stderr
        echo "find_nearby_zones():  conditions = [$conditions]" >/dev/stderr
    fi
    thiszone=${zname[$idx]}
    allnearbyzones=$(getalladj ${thiszone})
    nearbyzones=""
    if [[ $db -eq 1 ]]; then
        echo "find_nearby_zones():  allnearbyzones = [$allnearbyzones]" >/dev/stderr
    fi
    for thisone in $allnearbyzones; do
        ok=1
        zi=$(getidxfromname $thisone)
        if [[ $conditions == *open* && ${zstate[$zi]} != "open" ]]; then
            ok=0
        fi
        if [[ $conditions == *closed* && ${zstate[$zi]} != "close" ]]; then
            ok=0
        fi
        if [[ $conditions == *noaction* && ${zaction[$zi]} != "n/a" ]]; then
            ok=0
        fi
        if [[ $conditions == *open* && $constant == ${zname[$zi]} ]]; then
            # the constant zone never counts as an adjacent 'open' zone, because
            # if we were to close it, it would just get opened again.
            ok=0
        fi
        if [[ $ok -eq 1 ]]; then
            nearbyzones="$nearbyzones $thisone"
        fi
    done
    echo "$nearbyzones"
}

function all_zones_perfect() {
    local x
    for x in ${zperfect[@]}; do
        if [[ $x -ne 1 ]]; then
            return 1
        fi
    done
    return 0
}

function generate_actions() {    # populates global: nairconcommands & airconcmd[] & globprob
    local x y z adj tempstr nhot ncold
    local powerchange nmyzones maxpri bestidx
    local globaction mzmustmove poss nomyzone
    local db
    db=0
    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -en "${GREEN}${BOLD}>> ${PLAIN}${GREEN}Determining actions... ${PLAIN}"

    nairconcommands=0
    powerchange=""

    for x in ${!zname[@]}; do
        getzoneaction $x
#echo "zoneignore for ${zname[$x]} is ${zignore[$x]}" >/dev/stderr
    done

    # pass 1
    profile "pass 1 start"
    for x in ${!zname[@]}; do
        thisaction="${zaction[$x]}"
        IFS=' ' read -ra tok <<< "${zaction[$x]}"
        for y in ${!tok[@]}; do
            if [[ ${tok[$y]} == "close_nearby_zone" ]]; then
                # is there a nearby zone that's open?
                adj=$(find_nearby_zones $x open noaction)
                if [[ -z $adj ]]; then
                    zaction[$x]="power_off"
                    if [[ -z $powerchange ]]; then
                        powerchange="power_off"
                    elif [[ ${zaction[$x]} != $powerchange ]]; then
                        zactionfail[$x]=1
                    fi
                else
                    tempstr=""
                    for z in $adj; do
                        tempstr="$tempstr close:$z"
                    done
                    zaction[$x]="${zaction[$x]/close_nearby_zone/$tempstr}"
                fi
            fi
        done
    done

    # pass 2 - If multiple zones are too hot/cold, turn the whole system off/on (if off, replace all actions)
    nhot=0
    ncold=0
    for x in ${!zname[@]}; do
        if [[ -z $powerchange ]]; then
            if [[ ${zproblem[$x]} == "too_hot" ]]; then
                nhot=$((nhot + 1))
            elif [[ ${zproblem[$x]} == "too_cold" ]]; then
                ncold=$((ncold + 1))
            fi
        fi
    done

    globsetmode=""
    globprob=""
    if [[ $airconmode == "off" ]]; then
        # aircon is off
        if [[ $ncold -ge $limit ]]; then
            globprob="too_cold"
            if [[ $modelock == "n/a" || $modelock == "heat" ]]; then
                globsetmode=" set_mode:heat"
            fi
        elif [[ $nhot -ge $limit ]]; then
            globprob="too_hot"
            if [[ $modelock == "n/a" || $modelock == "cool" ]]; then
                globsetmode=" set_mode:cool"
            fi
        fi
        [[ -n $globsetmode ]] && globaction="power_on"
    else
        if [[ $airconmode == "heat" && $nhot -ge $limit ]]; then
            globprob="too_hot"
        elif [[ $airconmode == "cool" && $ncold -ge $limit ]]; then
            globprob="too_cold"
        elif [[ $ncold -eq 0 && $nhot -eq 0 ]]; then
        if all_zones_perfect; then
            globprob="not_needed"
        fi
        fi
        if [[ -n $globprob ]]; then
        globaction="power_off"
        [[ -z $powerchange ]] && powerchange="power_off"
    fi
    fi
    if [[ -n $globprob ]]; then
        for x in ${!zname[@]}; do
            if [[ ${zproblem[$x]} == $globprob && ${zaction[$x]} != *${globaction}* ]]; then
                zaction[$x]="$globaction$globsetmode ${zaction[$x]}"
                zactionfail[$x]=0
            elif [[ ${globaction} == "power_off" && ${zaction[$x]} != *$globaction* ]]; then
                zactionfail[$x]=1
            fi
        done
    fi

    # pass xx - if we're closing the constant zone, and it's NOT the myzone,
    # just turn the whole system off (since it will probably be opened.
    # again anyway).
    #
    if [[ -z $powerchange && $airconmode != "off" ]]; then
        for x in ${!zname[@]}; do
            if [[ ${zaction[$x]} == *close_vent* ]]; then
                if [[ $constant == ${zname[$x]} ]]; then
                    if [[ $airconmyzoneid != ${zid[$x]} ]]; then
                        zaction[$x]="power_off"
                        [[ -z $powerchange ]] && powerchange="power_off"
                    fi
                fi
            fi
        done
    fi

    # pass 3 - If we're powering the whole system on/off, don't do anything else
    if [[ -n $powerchange ]]; then
        for x in ${!zname[@]}; do
            if [[ ${powerchange} == "power_off" && ${zaction[$x]} != $powerchange ]]; then
                zactionfail[$x]=1
            fi
        done
    fi

    # pass xx - if we're closing the myzone, pick a new one
[[ $db -eq 1 ]] && info "pass 3 - powerchange is '$powerchange'"
    if [[ -z $powerchange ]]; then
        if [[ $airconmode != "off" ]]; then
            mzmustmove=0
                        # get list of all zones which can't be myzone
            nomyzone=""
            for x in ${!zname[@]}; do
            if [[ ${znomyzone[$x]} -eq 1 ]]; then
            nomyzone="$nomyzone ${zname[$x]} "
            fi
        done
            for x in ${!zname[@]}; do
                if [[ $airconmyzoneid == ${zid[$x]} || ${zaction[$x]} == *set_myzone* ]]; then
                    if [[ ${zstate[$x]} == "close" || ${zaction[$x]} == *close_vent* ]]; then
                        mzmustmove=1
                    elif [[ ${zaction[@]} == *close:${zname[$x]}* ]]; then
                        mzmustmove=1
                    elif [[ ${znomyzone[$x]} -eq 1 ]]; then
                        mzmustmove=1
                    fi
                    if [[ $mzmustmove -eq 1 ]]; then
[[ $db -eq 1 ]] && info "myzone must move away from ${zname[$x]}"
                        #info "myzone must move away from ${zname[$x]}"
                        zaction[$x]="${zaction[$x]/set_myzone/}"
                        nomyzone="$nomyzone ${zname[$x]} "
[[ $db -eq 1 ]] && info "zaction[${zname[$z]} is '${zaction[$x]}'"
[[ $db -eq 1 ]] && info "nomyzone is '$nomyzone'"
                    fi
                fi
            done
            if [[ $mzmustmove -eq 1 ]]; then
[[ $db -eq 1 ]] && info "got mzmustmove == 1"
[[ $db -eq 1 ]] && info "FINAL nomyzone is '$nomyzone}'"
                # find an alternative
                for x in ${!zname[@]}; do
                    # open or opening?  set myzone.  we'll resolve
                    # duplicates in the next step.
[[ $db -eq 1 ]] && info "   checking if we can move mz to ${zname[$x]}"
                    poss=0
                    if [[ ${zaction[$x]} != *set_myzone* && $nomyzone != *\ ${zname[$x]}\ * ]]; then
[[ $db -eq 1 ]] && info "   not already moving mz here + not in nomyzone list"
                        if [[ ${zstate[$x]} == "open" || ${zaction[$x]} == *open_vent* ]]; then
[[ $db -eq 1 ]] && info "   is open or opening -> OK"
                            poss=1
                        elif [[ ${zaction[@]} == *open:${zname[$x]}* ]]; then
[[ $db -eq 1 ]] && info "   is opening via adjacency-> OK"
                            poss=1
                        fi
                        if [[ $poss -eq 1 ]]; then
[[ $db -eq 1 ]] && info "  myzone could move to ${zname[$x]}"
                            #info "  myzone could move to ${zname[$x]}"
                            zaction[$x]="${zaction[$x]} set_myzone"
[[ $db -eq 1 ]] && info "  new zaction[${zname[$x]}] is ${zaction[x]}"
                        fi
                    fi
                done
            fi
        fi
    fi


    # pass 4 - multiple myzones?
    if [[ -z $powerchange ]]; then
        nmyzones=0
        maxpri=-999
        bestidx=-1
        for x in ${!zname[@]}; do
            # Multiple myzones?
            if [[ ${zaction[$x]} == *set_myzone* ]]; then
                #info "   ${zname[$x]} wants myzone (pri=${zpri[$x]} maxpri=$maxpri)"
                nmyzones=$((nmyzones + 1))
                if [[ $(echo "scale=1; ${zpri[$x]} > $maxpri" | bc) == "1" ]]; then
                    bestidx=$x
                    maxpri=$(echo "scale=1; ${zpri[$x]}" | bc)
                    #info "      new best priority: ${zname[$x]} = $maxpri"
                fi
            fi
        done
        if [[ $nmyzones -gt 1 ]]; then
            for x in ${!zname[@]}; do
                if [[ $x -ne $bestidx && ${zaction[$x]} == *set_myzone* ]]; then
                    zaction[$x]="${zaction[$x]/set_myzone/}"
                fi
            done
        fi
    fi

    # final pass
    for x in ${!zname[@]}; do
        if [[ ${zactionfail[$x]} -eq 0 ]]; then
            # Remove myzone if already set
            if [[ ${zaction[$x]} == *set_myzone* && $airconmyzoneid == ${zid[x]} ]]; then
                zaction[$x]="${zaction[$x]/set_myzone/}"
            fi

            # Remove leading spaces
            zaction[$x]=$(echo ${zaction[$x]} | awk '{$1=$1; sub("n/a ",""); sub(" n/a","") };1')
            # Generate actual aircon commands from zone commands
            gen_aircon_command ${x} ${zaction[$x]}
        fi
    done

    # if we are closing the constant zone and taking no other action,
    # just turn the system off.
    if [[ $nairconcommands -eq 1 ]]; then
        if [[ ${airconjcmd[0]} == *lose* ]]; then
            if [[ ${airconcmdzone[0]} == $constant ]]; then
                globprob="constant_close"
                globaction="power_off"
                [[ -z $powerchange ]] && powerchange="power_off"
            fi
        fi
    fi
    if [[ -n $globaction ]]; then
        gen_aircon_command -1 ${globaction}
    fi

    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -e "${GREEN}${BOLD}ok${PLAIN}"
}

# gen_aircon_command zone_idx "command1 command2 etc"
function gen_aircon_command() {
    local idx allactions this toadd num doneset othername otherid otherid2 otheridx db donemode str jtoadd="" id2
    idx=$1
    shift
    allactions="$*"
    doneset=0
    donemode=0

    db=0
    [[ $db -eq 1 ]] && info "gen_aircon_command() for idx=${idx}:  $allactions"

    IFS=' ' read -ra tok <<< "${allactions}"
    for this in ${tok[@]}; do
        if [[ $this == *power_on* ]]; then
            add_aircon_command $idx -1 "Power on system" "on" '"info":{"state":"on"}'

        elif [[ $this == *power_off* ]]; then
            add_aircon_command $idx -1 "Power off system" "off" '"info":{"state":"off"}'
        elif [[ $this == *set_myzone* && $airconmyzoneid != ${zid[$idx]} ]]; then
        [[ $idx -eq -1 ]] && continue
            add_aircon_command $idx -1 "Set MyZone to ${zname[$idx]}" "myzone --zone ${zid[$idx]}" "\"info\":{\"myZone\":${zid[$idx]}}"
        elif [[ $this == *open:* ]]; then
            # open vent in another zone
            [[ $idx -eq -1 ]] && continue
            othername=$(echo "$this" | sed -e 's/^.*open://;s/ .*//')
            otheridx=$(getidxfromname $othername)
            otherid=${zid[$otheridx]}
            otherid2=$(printf "z%02d" "$otherid")
            add_aircon_command $idx $otheridx "Open vent in ${zname[$otheridx]}" "set --zone ${otherid} --state on --temp ${zsettemp[$otheridx]}" "\"zones\":{\"${otherid2}\":{\"state\":\"open\",\"setTemp\",${zsettemp[$otheridx]}}"
        elif [[ $this == *close:* ]]; then
            # close vent in another zone
            [[ $idx -eq -1 ]] && continue
            othername=$(echo "$this" | sed -e 's/^.*close://;s/ .*//')
            otheridx=$(getidxfromname $othername)
            otherid=${zid[$otheridx]}
            otherid2=$(printf "z%02d" "$otherid")
            add_aircon_command $idx $otheridx "Close vent in ${zname[$otheridx]}" "set --zone ${otherid} --state off --temp ${zsettemp[$otheridx]}" "\"zones\":{\"${otherid2}\":{\"state\":\"close\",\"setTemp\",${zsettemp[$otheridx]}}"

        elif [[ $this == *set_mode:* ]]; then
            str=$(echo "$this" | sed -e 's/^.*set_mode://;s/ .*//')
            add_aircon_command $idx -1 "Set system mode to '$str'" "$str" "\"info\":{\"mode\":\"${str}\"}"
        elif [[ $this == *set_temp* || $this == *open_vent* || $this == *close_vent* ]]; then
            [[ $idx -eq -1 ]] && continue
            if [[ $doneset -eq 0 ]]; then
                id2=$(printf "z%02d" "${zid[$idx]}")
                jtoadd="\"zones\":{\"${id2}\":{"
                toadd=""
                comm=""
                if [[ $allactions == *open_vent* ]]; then
                    toadd="$toadd --state on"
                    jtoadd="${jtoadd}\"state\":\"open\","
                    comm="open vent"
                elif [[ $allactions == *close_vent* ]]; then
                    toadd="$toadd --state off"
                    jtoadd="${jtoadd}\"state\":\"close\","
                    comm="close vent"
                fi
                if [[ $allactions == *set_temp* ]]; then
                    num=$(echo "$this" | sed -e 's/^.*set_temp://;s/ .*//')
                    toadd="$toadd --temp $num"
                    jtoadd="${jtoadd}\"setTemp\":\"$num\","
                    [[ -n $comm ]] && comm="${comm} and "
                    comm="${comm}set temperature to $num degrees"
                else
                    toadd="$toadd --temp ${zsettemp[$idx]}"
                    jtoadd="${jtoadd}\"setTemp\":\"${zsettemp[$idx]}\","
                fi
                if [[ -n $toadd ]]; then

                    jtoadd="${jtoadd/%,/}}}" # remove trailing comma, add closing braces
                    add_aircon_command $idx -1 "In zone ${zname[$idx]}, $comm" "set --zone ${zid[$idx]}$toadd" "$jtoadd"
                    doneset=1
                fi
            fi
        fi
    done
}

# add_aircon_command zone_idx zone_idx2 "comment goes here" "textual version of command to run" "json command"
function add_aircon_command() {
    local x idx otheridx comment db cmd jcmd

    [[ $# -le 1 ]] && return 1

    idx=$1
    shift
    otheridx=$1
    shift
    comment=$1
    shift
    cmd="$1"
    shift
    jcmd="{ \"ac1\":{"
    jcmd="${jcmd}$1"
    jcmd="${jcmd} } }"

    if [[ $otheridx -ne -1 ]]; then
        if [[ -n $comment ]]; then
            comment="${comment} (to fix ${zname[$idx]})"
        fi
    fi

    db=0
    [[ $db -eq 1 ]] && info "   add_aircon_command() for idx=${idx} otheridx=${otheridx} comment=[$comment]:  $*" >/dev/stderr

    [[ -z $* ]] && return 1

    # already got this command queued?
    for x in ${airconcmd[@]}; do
        if  [[ $x == "$*" ]]; then
            return 1
        fi
    done
    airconcmd[$nairconcommands]="$cmd"
    airconjcmd[$nairconcommands]="$jcmd"
    airconcomment[$nairconcommands]="$comment"
    if [[ $idx -eq -1 ]]; then
        airconcmdzone[$nairconcommands]="Aircon"
        airconproblem[$nairconcommands]="Aircon is not needed at this time."
    else
        airconcmdzone[$nairconcommands]="${zname[$idx]}"
        if [[ ${zproblem[$idx]} == "n/a" ]]; then
            # global problem
            if [[ -n $globprob ]]; then
                airconproblem[$nairconcommands]="$(describe_globprob)"
            else
                airconproblem[$nairconcommands]="Unknown"
            fi
        else
            # zone-specific problem
            airconproblem[$nairconcommands]="${zname[$idx]} is ${zproblem[$idx]/_/ }"
        fi
    fi

    if [[ $otheridx -eq -1 ]]; then
        airconcmdotherzone[$nairconcommands]=""
    else
        airconcmdotherzone[$nairconcommands]="${zname[$otheridx]}"
    fi
    #if [[ $otheridx -ne -1 ]]; then
    #    airconcomment[$nairconcommands]="${airconcomment[$nairconcommands]}, update nearby zone ${zname[$otheridx]}"
    #fi
    nairconcommands=$((nairconcommands + 1))
    return 0

}

function addnoop() {
    local idx
    idx=$(getidxfromname "$1")
    zignore[$idx]=1
}

function addnomyzone() {
    local idx
    idx=$(getidxfromname "$1")
    znomyzone[$idx]=1
}

function addforcevent() {
    local x idx
    idx=$nforcevents
    for x in ${!fv_zonename[@]}; do
        if [[ ${fv_zonename[$x]} == "$1" ]]; then
            idx=$x
            break;
        fi
    done
    fv_zonename[$idx]="$1"
    fv_state[$idx]="$2"
    [[ $idx == $nforcevents ]] && nforcevents=$((nforcevents + 1))
}

function addtemprange() {  # [-s]   idx  min-max       -s means 'set zwanttemp+zwantmin+zwantmax too'
    local x idx doset=0
    if [[ $1 == "-s" ]]; then
        doset=1
        shift
    fi
    idx=$ntempranges
    for x in ${!tr_zonename[@]}; do
        if [[ ${tr_zonename[$x]} == "$1" ]]; then
            idx=$x
            break;
        fi
    done

    tr_zonename[$idx]="$1"
    tr_range[$idx]="$2"

    if [[ $doset -eq 1 ]]; then
        local wanttemp zidx
        wanttemp=$(gettemprange "$1")
        zidx=$(getidxfromname "$1")
        if [[ $wanttemp == "n/a" ]]; then
            zwanttemp[$zidx]="n/a"
            zwantmin[$zidx]="-99"
            zwantmax[$zidx]="99"
        else
            zwanttemp[$zidx]="$wanttemp"
            zwantmin[$zidx]="${wanttemp%-*}"
            zwantmax[$zidx]="${wanttemp#*-}"
        fi
    fi
    [[ $idx == $ntempranges ]] && ntempranges=$((ntempranges + 1))
}

function addadj() {
    local name
    name="$1"
    shift
    adj_zonename[$nadj]="$name"
    adj_nearby[$nadj]="$*"
    nadj=$((nadj + 1))
}

function addperson() {
    local h p x idx db
    db=0

    p="$1"
    shift
    h="$*"

    [[ $db -eq 1 ]] && info "addperson() person $p host(s) [$h]"

    idx=$npeople
    for x in ${!pname[@]}; do
        if [[ ${pname[$x]} == "$p" ]]; then
            [[ $db -eq 1 ]] && info "  owner already exists, appending."
            idx=$x
            break;
        fi
    done
    pname[$idx]="$p"
    if [[ ${pdev[$idx]} != *\ $h\ * ]]; then
        pdev[$idx]="${pdev[$idx]} $h "
    fi
    [[ $db -eq 1 ]] && info "  dev val is:  ${pdev[$idx]}"
    [[ $idx == $npeople ]] && npeople=$((npeople + 1))
}

function addowner() {  #  zone    "host1 host2 ..."
    local z h local x idx db doset=0
    local zidx
    db=0
    if [[ $1 == "-s" ]]; then
        doset=1
        shift
    fi

    z="$1"
    shift
    h="$*"


    zidx=$(getidxfromname "$z")  # get the index into the zname[] etc arrays
    if [[ $zidx -eq -1 ]]; then
        error "Failed to set owner of zone '$z' to '$h' - zone doesn't exist. "
        exit 1;
    fi

    [[ $db -eq 1 ]] && info "addowner() zone $z host(s) [$h]"

    idx=$nowners
    for x in ${!ownerzone[@]}; do
        if [[ ${ownerzone[$x]} == "$z" ]]; then
            [[ $db -eq 1 ]] && info "  owner already exists, appending."
            idx=$x
            break;
        fi
    done
    ownerzone[$idx]="$z"
    if [[ ${ownerhost[$idx]} != *\ $h\ * ]]; then
        ownerhost[$idx]="${ownerhost[$idx]} $h "
    fi
    [[ $db -eq 1 ]] && info "  hosts val is:  ${ownerhost[$idx]}"
    [[ $idx == $nowners ]] && nowners=$((nowners + 1))

    if [[ $doset -eq 1 ]]; then
        zowner[$zidx]="${ownerhost[$idx]}";

        [[ $db -eq 1 ]] && info "  doing set of zowner[$zidx] (${zname[$zidx]}} to [${ownerhost[$idx]}]"
        #zownerperson[$zidx]=$(getownerperson "$z");  # may be overwritten later
    fi
}

# getownerperson zone_name
# returns name of person who owns zone
#function getownerperson() {
#    local x retval
#    retval=""
#    for x in ${!ownerzone[@]}; do
#        if [[ ${ownerzone[$x]} == "$1" ]]; then
#            retval="${ownerperson[$x]}"
#            break
#        fi
#    done
#    echo "$retval"
#}

# getowner zone_name
# returns devices associated with zone
function getowner() {
    local x retval
    retval=""
    for x in ${!ownerzone[@]}; do
        if [[ ${ownerzone[$x]} == "$1" ]]; then
            retval="${ownerhost[$x]}"
            break
        fi
    done
    echo "$retval"
}

# gettemprange zone_name
function gettemprange() {
    local x retval
    retval="n/a"
    for x in ${!tr_zonename[@]}; do
        if [[ ${tr_zonename[$x]} == "$1" ]]; then
            retval="${tr_range[$x]}"
            break
        fi
    done
    echo "$retval"
}

function getstrtype() {
    local strtype
    shopt -s nocasematch
    strtype=unknown
    if [[ "$*" =~ ^[0-9]{4}$ ]]; then
        strtype="24h"
    elif [[ "$*" =~ ^(mon|tue|wed|thu|fri|sat|sun)$ ]]; then
        strtype="weekday"
    fi
    shopt -u nocasematch
    echo "$strtype"
}

function weekdaytonum() {
    local num
    shopt -s nocasematch
    num=-1
    case "$1" in
        "mon") num=1;;
        "tue") num=2;;
        "wed") num=3;;
        "thu") num=4;;
        "fri") num=5;;
        "sat") num=6;;
        "sun") num=7;;
    esac
    shopt -u nocasematch
    echo "$num"
}

function weekdaytofull() {
    local full
    shopt -s nocasematch
    num=-1
    case "$1" in
        "mon") full="Monday";;
        "tue") full="Tuesday";;
        "wed") full="Wednesday";;
        "thu") full="Thursday";;
        "fri") full="Friday";;
        "sat") full="Saturday";;
        "sun") full="Sunday";;
    esac
    shopt -u nocasematch
    echo "$full"
}

function conderror() {
    error "Invalid condition: $1"
    echo -e "${RED}   Start: $2"
    echo -e "${RED}   End:   $3"
}

function load_config() {
    local line rv timestr ttok stype ok starth endh nowh
    local cond allconds x
    local db
    parse_config || return 1
    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -en "${GREEN}${BOLD}>> ${PLAIN}${GREEN}Loading config file... ${PLAIN}"
    db=0
    rv=0
    while read line; do
        ok=1 # default to okay
        line=${line%%#*}  # remove comments
        if [[ -n ${line// } ]]; then
            # time based options
            if [[ ${line:0:1} == "@" ]]; then
                processtimeconditions "$line" || ok=0
                if [[ $ok -eq 1 ]]; then
                    # strip condition off the front
                    line=${line#* }
                fi
            else
                ok=1
            fi
            if [[ $ok -eq 1 ]]; then
                IFS=' ' read -ra tok <<< "$line"
                if [[ ${tok[0]} == "temp" ]]; then
                    addtemprange -s ${tok[1]} ${tok[2]}
                elif [[ ${tok[0]} == "constant" ]]; then
                    constant=${tok[1]}
                elif [[ ${tok[0]} == "adj" ]]; then
                    addadj ${tok[1]} ${tok[@]:2}
                elif [[ ${tok[0]} == "nomyzone" || ${tok[0]} == "nomy" ]]; then
                    addnomyzone ${tok[1]}
                elif [[ ${tok[0]} == "noop" || ${tok[0]} == "ignore" ]]; then
                    addnoop ${tok[1]}
                elif [[ ${tok[0]} == "force" ]]; then
                    addforcevent ${tok[1]} ${tok[2]}
                elif [[ ${tok[0]} == "owner" ]]; then
                    addowner -s ${tok[1]} ${tok[@]:2}
                elif [[ ${tok[0]} == "person" ]]; then
                    addperson ${tok[1]} ${tok[@]:2}
                elif [[ ${tok[0]} == "modelock" ]]; then
                    modelock="${tok[1]}"
                elif [[ ${tok[0]} == "test" ]]; then
                    info "Got test option:  '${tok[@]}'"
                    rv=1
                fi
            fi
        fi
    done < "$CONFIGFILE"
    if [[ $cronmode -eq 0 && $logmode -eq 0 ]]; then
        if [[ $rv -eq 0 ]]; then
            echo -e "${GREEN}${BOLD}ok${PLAIN}"
        else
            echo -e "${RED}${BOLD}fail${PLAIN}"
        fi
    fi
    return $rv
}

# pooulates global timestr_human, -c means keep going if we dont match
function processtimeconditions() {
    local timestr line allconds cond
    local ttok stype nowh starth endh
    local this_human
    local keepgoing=0
    local ok=0
    local nonmatches=0
    local rv
    local db=0
    if [[ $RULEDB -eq 1 ]]; then
        db=1
    fi
    if [[ $1 == "-c" ]]; then
        keepgoing=1
        shift 1
    fi
    line="$*"
    timestr_human=""

    timestr=${line%% *}  # only process first word
    timestr=${timestr:1} # strip leading @
    [[ $db -eq 1 ]] && info "${BOLD}Processing line: '$line'"
    IFS=';' read -ra allconds <<< "$timestr"
    for cond in ${allconds[@]} ; do
            [[ $db -eq 1 ]] && info "  processing condition: '$cond'"
            IFS='-' read -ra ttok <<< "$cond"
            if [[ ${#ttok[@]} == 1 ]]; then
                    stype[0]=$(getstrtype ${ttok[0]})
                    if [[ ${stype[0]} != "weekday" ]]; then
                            error "Invalid condition:  '${cond}'"
                            return 1
                    fi
                    starth=$(weekdaytonum ${ttok[0]})
                    if [[ $starth -eq -1 ]]; then
                            error "'${ttok[0]}' is not a valid type here (type is ${stype[0]})"

                            return 1
                    fi
                    endh="$starth"
                    nowh=$(date +%u)

                    [[ -n $timestr_human ]] && this_human="o " || this_human=O
                    this_human=$(printf "${this_human}n _H_%ss_EH_" $(weekdaytofull ${ttok[0]}))

            else
                    stype[0]=$(getstrtype ${ttok[0]})
                    stype[1]=$(getstrtype ${ttok[1]})
                    starth=""
                    endh=""
                    nowh=""
                    if [[ ${stype[0]} != ${stype[1]} ]]; then
                            error "start and end condition types don't match:"
                            echo -e "${RED}   Start: ${ttok[0]} (${stype[0]})${PLAIN}"
                            echo -e "${RED}   End:   ${ttok[1]} (${stype[1]})${PLAIN}"
                            return 1
                    elif [[ ${stype[0]} == "24h" ]]; then
                            starth=${ttok[0]}
                            endh=${ttok[1]}
                            nowh=$(date +%H%M)

                            [[ -n $timestr_human ]] && this_human=" b" || this_human=B
                            this_human=$(printf "${this_human}etween _H_%02s:%02s_EH_ and _H_%02s:%02s_EH_" ${starth:0:2} ${starth:2:2} ${endh:0:2} ${endh:2:2})
                    elif [[ ${stype[0]} == "weekday" ]]; then
                            starth=$(weekdaytonum ${ttok[0]})
                            endh=$(weekdaytonum ${ttok[1]})
                            if [[ $starth -eq -1 || $endh -eq -1 ]]; then
                                    conderror "${cond}" "'${ttok[0]}' (${stype[0]})" "'${ttok[1]}' (${stype[1]})"

                                    return 1
                            fi
                            nowh=$(date +%u)
                            if [[ ${ttok[0]} == ${ttok[1]} ]]; then
                                [[ -n $timestr_human ]] && this_human="o " || this_human=O
                                this_human=$(printf "${this_human}n _H_%ss_EH_" ${ttok[0]})
                            else
                                [[ -n $timestr_human ]] && this_human=" f" || this_human=F
                                this_human=$(printf "${this_human}rom _H_%s_EH_ to _H_%s_EH_" ${ttok[0]} ${ttok[1]})
                            fi
                    else
                            conderror "${cond}" "'${ttok[0]}' (${stype[0]})" "'${ttok[1]}' (${stype[1]})"
                            return 1
                    fi
            fi  #  end if ttokcount
            if [[ -n $starth ]]; then
                    [[ $db -eq 1 ]] && info "   check if $nowh is between $starth and $endh"
                    ok=0
                    if [[ $(echo "$starth < $endh" | bc) == "1" ]]; then
                            [[ $db -eq 1 ]] && info "   time period does NOT span midnight"
                            if [[ $(echo "$nowh >= $starth" | bc) == "1" && $(echo "$nowh <= $endh" | bc) == "1" ]]; then
                                    ok=1
                            fi
                    elif [[ $(echo "$starth > $endh" | bc) == "1" ]]; then
                            [[ $db -eq 1 ]] && info "   time period spans midnight"
                            if [[ $(echo "$nowh <= $endh" | bc) == "1" || $(echo "$nowh >= $starth" | bc) == "1" ]]; then
                                    ok=1
                            fi
                    else
                            if [[ $nowh == $endh || $nowh == $starth ]]; then
                                    ok=1
                            fi
                    fi
                    [[ $ok -eq 0 ]] && nonmatches=$((nonmatches + 1))
                    [[ $db -eq 1 && $ok -eq 0 ]] && info "   $nowh isn't in range $cond"
                    [[ $db -eq 1 && $ok -eq 1 ]] && info "   MATCH: $nowh within range $cond"
            fi  # end if condition matches
            timestr_human="${timestr_human}${this_human}"
            if [[ $ok -eq 0 && $keepgoing -eq 0 ]]; then
                    break
            fi
    done

    [[ $db -eq 1 ]] && info "  ok=$ok    nonmatches=$nonmatches"

    if [[ $ok -eq 0 || $nonmatches -gt 0 ]]; then
        rv=1
    else
        rv=0
    fi
    [[ $db -eq 1 ]] && info "  returning $rv"
    return $rv
}

function active_cols() {
    if [[ $RULEFORMAT == "html" ]]; then
        plainc="<font color=#000000></strong></s>"  # black
        inactc="<font color=#ff0000>"          # red
        linec="<font color=#000000></strong></s>"  # black
        devc="<font color=#00aa00>"            # green+bold
        devbc="<strong><font color=#00aa00>"   # green
        statec="<strong><font color=#bbbb00>"  # yellow+bold
        roomc="<font color=#ffa500>"           # orange
        timec="<font color=#ff97c6>"           # pink
        timebc="<strong><font color=#ff97c6>"  # pink+bold
        minc="<strong><font color=#0000dd>"    # blue+bold
        maxc="<strong><font color=#dd0000>"    # red+bold
        coolc="<strong><font color=#00dddd>"   # cyan+bold
        heatc="<strong><font color=#dd0000>"   # red+bold
        nl="<br></s></strong><font color=#000000>\n"
    else
        plainc=${PLAIN}
        inactc="$RED"
        linec=${PLAIN}
        devc="$GREEN"
        devbc="$BOLD$devc"
        statec="$BOLD$YELLOW"
        roomc="$ORANGE"
        timec="$PINK"
        timebc="$BOLD$timec"
        minc="$BOLD$BLUE"
        maxc="$BOLD$RED"
        coolc="$BOLD$CYAN"
        heatc="$RED"
        nl="\n"
    fi
}

function inactive_cols() {
    if [[ $RULEFORMAT == "html" ]]; then
        plainc="<font color=#000000></strong></s>"  # black
        inactc="<s><font color=#aaaaaa>"    # lightgrey
        linec=""
        devc=""
        devbc=""
        statec=""
        roomc=""
        timec=""
        timebc=""
        minc=""
        maxc=""
        nl="</s><br>\n"
    else
        plainc=${PLAIN}
        inactc="$DARKGREY"
        linec="${inactc}"
        devc="$inactc"
        devbc="$inactc"
        statec="$inactc"
        roomc="$inactc"
        timec="$inactc"
        timebc="$inactc"
        minc="$inactc"
        maxc="$inactc"
        nl="\n"
    fi
}

function parse_config() {
    local line rv timestr ttok stype ok starth endh nowh
    local cond allconds x
    local db fileok=1 linenum show=0
    local config_human line_human errstr
    local ign="" thisignored=0 oneof

    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -en "${GREEN}${BOLD}>> ${PLAIN}${GREEN}Parsing config file... ${PLAIN}"
    if [[ -n $1 ]]; then
        show=$1
    fi
    db=0
    rv=0
    config_human=""
    errstr=""
    linenum=1
    while read line; do
        ok=1
        active_cols
        line=${line%%#*}  # remove comments
        thisignored=0
        line_human=""
        if [[ -n ${line// } ]]; then
            # time based options
            if [[ ${line:0:1} == "@" ]]; then
                # strip condition off the front
                processtimeconditions -c "$line" || ok=0
                [[ $ok -eq 0 ]] && inactive_cols
                line=${line#* }
                if [[ -n $timestr_human ]]; then
                    local modts
                    modts=${timestr_human//_H_/$timebc}
                    modts=${modts//_EH_/$linec$timec}
                    line_human="${timec}$modts${linec}, "
                fi
            fi

            IFS=' ' read -ra tok <<< "$line"
            if [[ ${tok[0]} == "temp" ]]; then
                local min max
                min=${tok[2]%-*}
                max=${tok[2]#*-}
                [[ $ign == *\ ${tok[1]}* ]] && thisignored=1 # zone is being ignored
                [[ $thisignored -eq 1 ]] && inactive_cols
                line_human="${line_human}Keep temperature of ${roomc}${tok[1]}${linec} between ${minc}${min}${linec}-${maxc}${max}${linec} degrees"
            elif [[ ${tok[0]} == "constant" ]]; then
                true
            elif [[ ${tok[0]} == "person" ]]; then
                true
            elif [[ ${tok[0]} == "adj" ]]; then
                true
            elif [[ ${tok[0]} == "nomyzone" || ${tok[0]} == "nomy" ]]; then
                line_human="${line_human}Prevent ${roomc}${tok[1]}${linec} from being the MyZone"
            elif [[ ${tok[0]} == "noop" || ${tok[0]} == "ignore" ]]; then
                line_human="${line_human}Ignore ${roomc}${tok[1]}${linec} temperature when deciding what to do"
                [[ $ok -eq 1 ]] && ign="${ign} ${tok[1]}"
            elif [[ ${tok[0]} == "force" ]]; then
                if [[ $VALID_ZONE_STATES == *\ ${tok[2]}\ * ]]; then
                    local adj
                    adj="${tok[2]}"
                    [[ $adj != "open" ]] && adj="${adj}d"
                    line_human="${line_human}Force the vent in ${roomc}${tok[1]}${linec} to be ${statec}${adj}${linec}"
                else
                    errstr="${errstr}${linenum}:Invalid zone state '${tok[2]}'.  Valid options are: $VALID_ZONE_STATES$nl"
                    fileok=0
                fi
            elif [[ ${tok[0]} == "owner" ]]; then
                local devices verb
                devices="${devc}${tok[@]:2}${linec}"
                if [[ ${#tok[@]} -eq 3 ]]; then
                    verb="isn't"
                    oneof=""
                    devices="${devbc}${linec}${devices}${devbc}${linec}"
                else
                    verb="aren't"
                    oneof=" one of"
                    devices="${devbc}(${linec}${devices}${devbc})${linec}"
                fi
                line_human="${line_human}${statec}Close${linec} vent in ${roomc}${tok[1]}${linec} if${oneof} $devices $verb online"
            elif [[ ${tok[0]} == "modelock" ]]; then
                if [[ $VALID_MODES == *\ ${tok[1]}\ * ]]; then
                    local col
                    modelock="${tok[1]}"
                    [[ $modelock == "cool" ]] && col="$coolc" || col="$heatc"
                    line_human="${line_human}Only operate the aircon in ${col}${tok[1]}${linec} mode"
                else
                    errstr="${errstr}${linenum}:Invalid modelock '${tok[1]}'.  Valid options are: $VALID_MODES$nl"
                    fileok=0
                fi
            elif [[ ${tok[0]} == "test" ]]; then
                line_human="${line_human}Got test option '${roomc}${tok[1]}${linec}'"
            elif [[ -n $line ]]; then
                errstr="${errstr}${linenum}:Syntax error: ${line}$nl"
                fileok=0
            fi
        fi
        if [[ -n $line_human ]]; then
            if [[ $ok -eq 0 ]]; then
                line_human="${plainc}${inactc}[out-of-hours] ${linec}${line_human}"
            elif [[ $thisignored -eq 1 ]]; then
                line_human="${plainc}${inactc}[ignored] ${linec}${line_human}"
            fi
            config_human="${config_human}- ${linec}${line_human}${plainc}$nl"
        fi
        linenum=$((linenum + 1))
    done < "$CONFIGFILE"

    if [[ $fileok -eq 1 ]]; then
        [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -e "${GREEN}${BOLD}ok${PLAIN}"
        if [[ $show -eq 2 ]]; then
            echo -e "${config_human}"
        elif [[ $show -eq 1 ]]; then
            info "Configuration file is ${BOLD}OK"
        fi
        rv=0
    else
        [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -e "${RED}${BOLD}fail${PLAIN}"
        error "Configuration file is invalid:"
        echo -e "${RED}$errstr${plainc}" | sed -e 's/^/   /'
        rv=1
    fi
    return $rv
}

# if we can ping ANY of the args, return ok
function canping() {
    local n hname ip db host success=0 mac
    local os arprv arpres
    os=$(uname -s)
    db=0
    if [[ $db -eq 1 ]]; then
        info "canping() for:"
        for host in $*; do
            info "  - '${host}'"
        done
    fi
    # get ip and clear arp
    n=0
    for host in $*; do
        hname[$n]="$host"
        if [[ $os == "Darwin" ]]; then
            ip[$n]=$(dscacheutil -q host -a name $host | grep ^ip_address: | awk '{ print $NF}')
        else
            ip[$n]=$(getent hosts $host | grep -v : | awk '{ print $1 }')
        fi
        if [[ -n ${ip[$n]} ]]; then
            arp -d ${ip[$n]} >/dev/null 2>&1
        fi
        n=$((n + 1))
    done

    # send new arp req
    for n in ${!ip[@]}; do
        if [[ -n ${ip[$n]} ]]; then
            if [[ -e $ARPING ]]; then
                    ${ARPING} -c10 -W0.2 -w4 -C1 -q ${ip[$n]} 2>/dev/null &
            else
                    ping -c 1 -w 1 -q ${ip[$n]} 2>/dev/null &
            fi
        fi
    done

    # wait for arp replies or timeout
    wait
    sleep 0.4

    # now check entries
    for n in ${!ip[@]}; do
        [[ $db -eq 1 ]] && info "   recheck ${hname[$n]} (${ip[$n]})"
        if [[ -n ${ip[$n]} ]]; then
            arpres=$(arp -n ${ip[$n]} 2>/dev/null)
            arprv=$?
            mac=$(echo "$arpres" | egrep -v "Host|xpired" | awk '{print $2}')
            [[ $mac == *:* ]] && success=1
        fi
        [[ $db -eq 1 ]] && info "   ${hname[$n]} (${ip[$n]}) mac is mac=$mac"
        [[ $db -eq 1 ]] && info "canping() ${hname[$n]} (${ip[$n]}) is $success"

        if [[ $success -eq 1 ]]; then
            return 0
        fi
    done
    return 1
}

function addzone() {
    local name state settemp temp wanttemp wanttempmin wanttempmax id
    name="$1"
    state="$2"
    settemp="$3"
    temp="$4"
    id="$5"
    zname[$nzones]="$name"
    zstate[$nzones]="$state"
    zsettemp[$nzones]="$settemp"
    ztemp[$nzones]="$temp"
    zid[$nzones]="$id"
    zwanttemp[$nzones]="n/a"
    zperfect[$nzones]=0
    zproblem[$nzones]="n/a"
    zaction[$nzones]="n/a"
    zactionfail[$nzones]=0
    zowner[$nzones]=$(getowner "$name")                 # devices which 'own' the zone - may be overwritten later
    #zownerperson[$nzones]=$(getownerperson "$name")     # may be overwritten later
    zownerhome[$nzones]=1
    #info "zone $name owner is [${zowner[$nzones]}]"
    zignore[$nzones]=0
    znomyzone[$nzones]=0
    zpri[$nzones]=0
    wanttemp=$(gettemprange "$name")
    if [[ $wanttemp == "n/a" ]]; then
        zwanttemp[$nzones]="n/a"   # default - this will be overridden in load_config
        zwantmin[$nzones]="-99"    # default - this will be overridden in load_config
        zwantmax[$nzones]="99"    # default - this will be overridden in load_config
    else
        zwanttemp[$nzones]="$wanttemp"
        zwantmin[$nzones]="${wanttemp%-*}"
        zwantmax[$nzones]="${wanttemp#*-}"
    fi

    nzones=$((nzones + 1))
}

function getcol() {
    local col
    case $1 in
        "off") col="$GREY";;
        "cool") col="$CYAN";;
        "heat") col="$RED";;
        *) col="$PLAIN";;
    esac
    echo $col
}

function gen_config() {
    local x
    if [[ -e $CONFIGFILE ]]; then
        error "$CONFIGFILE already exists"
        return 1
    fi
    get_aircon_info
    cp /dev/null $CONFIGFILE
    echo "# Specify commandline args here" >> $CONFIGFILE
    echo "# options -p -t 0.3 ... " >> $CONFIGFILE
    echo >> $CONFIGFILE
    echo "# Don't switch to modes other than this" >> $CONFIGFILE
    echo "#modelock heat|cool" >> $CONFIGFILE
    echo >> $CONFIGFILE
    echo "# Set temperature range to enforce" >> $CONFIGFILE
    for x in ${!zname[@]}; do
        echo "#temp ${zname[$x]} min_temp-max_temp" >> $CONFIGFILE
    done
    echo >> $CONFIGFILE
    echo "# Turn off zone if we can't ARP for given hostname's IP" >> $CONFIGFILE
    for x in ${!zname[@]}; do
        echo "#owner ${zname[$x]} hostname.domain" >> $CONFIGFILE
    done
    echo >> $CONFIGFILE
    echo "# Define which zones are adjacent to each other (used to close nearby" >> $CONFIGFILE
    echo "# zones to help control temperature)" >> $CONFIGFILE
    for x in ${!zname[@]}; do
        echo "#adj ${zname[$x]} adjacent_zone1 [adjacent_zone2] ... [adjacent_zoneX]" >> $CONFIGFILE
    done
    echo >> $CONFIGFILE
    echo "# Force a zone into a certain state" >> $CONFIGFILE
    echo "#force ${zname[0]} open" >> $CONFIGFILE
    echo "#force ${zname[1]} close" >> $CONFIGFILE
    echo >> $CONFIGFILE
    echo "# All commands except options can be restricted to certain times with:" >> $CONFIGFILE
    echo "#    @hhmm-hhmm     Restrict between certain 24 hour times" >> $CONFIGFILE
    echo "#    @Mon-Wed       Restrict between certain weekdays" >> $CONFIGFILE
    echo "#    @Mon           Restrict to one weekdays only" >> $CONFIGFILE

    echo "#    @Mon;hhmm-hhmm Restrict both day and time" >> $CONFIGFILE
    echo "# For example:" >> $CONFIGFILE
    echo "# Keep zone closed on Tuesdays and Wednesdays" >> $CONFIGFILE
    echo "#@Tue-Wed force ${zname[0]} close" >> $CONFIGFILE
    echo "# Override temperature range between 11pm and 5am" >> $CONFIGFILE
    echo "#@2300-0500 temp ${zname[0]} 20-21" >> $CONFIGFILE
    echo "# Keep zone open between 10am and 11am on Mondays" >> $CONFIGFILE
    echo "#@Mon;1000-1100 force ${zname[0]} open" >> $CONFIGFILE
}

function get_aircon_info() {
    local jsoninfo url state
    profile "query aircon"
    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -en "${GREEN}${BOLD}>> ${PLAIN}${GREEN}Querying aircon... ${PLAIN}"
url="${AIRCON_URL}/getSystemData"
    jsoninfo=$(curl -s "$url" 2>/dev/null)
    if [[ $? -ne 0 ]]; then
        error "get_aircon_info() failed to reach ${AIRCON_URL}/getSystemData endpoint"
        exit 1;
    fi
    echo "$jsoninfo" | jq . &>/dev/null
    if [[ $? -ne 0 ]]; then
        error "${AIRCON_URL}/getSystemData returned bad json:  $jsoninfo"
        exit 1;
    fi
    zones=$(echo "$jsoninfo" | $JQ -r '.aircons.ac1.zones[] | [ .name, .state, .setTemp, .measuredTemp, .number ] | @csv' | tr -d '" ')
    state=$(echo "$jsoninfo" | $JQ -r '.aircons.ac1.info.state' | tr -d '" ')
    if [[ $state == "off" ]]; then
        airconmode="off"
    else
        airconmode=$(echo "$jsoninfo" | $JQ -r '.aircons.ac1.info.mode' | tr -d '" ')
    fi
    airconmyzoneid=$(echo "$jsoninfo" | $JQ -r '.aircons.ac1.info.myZone ' | tr -d '" ')
    nzones=0
    for line in $zones; do
        IFS=',' read -ra tok <<< "$line"
        addzone "${tok[0]}"  "${tok[1]}"  "${tok[2]}"  "${tok[3]}" "${tok[4]}"
    done
    if [[ $nzones -eq 0 ]]; then
        error "get_aircon_info() found no zones"
        exit 1;
    fi
    airconmyzone=$(getnamefromid $airconmyzoneid)
    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -e "${GREEN}${BOLD}ok${PLAIN}"
    profile "query aircon"
}

function show_aircon_status() {
    local zonestr zonecol settempcol actioncol thiswantcol thisstate thisstateform
    local actualtempformat x powercol lockcol actionstr
    local FORMAT1 FORMAT2 FORMATHOT FORMATCOLD FORMATOK CLOSEDFORM OPENFORM
    local ownercol ownerform

    FORMAT1="${BOLD}%-16s%-9s%-8s%-7s%-7s%-7s%s${PLAIN}"
    FORMAT2="${UNDERLINE}${FORMAT1}${PLAIN}"
    FORMATHOT="${RED}%-7s${PLAIN}"
    FORMATCOLD="${CYAN}%-7s${PLAIN}"
    FORMATOK="${WHITE}%-7s${PLAIN}"
    FORMATPERFECT="${GREEN}%-7s${PLAIN}"
    CLOSEDFORM="$GREY%-8s$PLAIN"
    OPENFORM="$PLAIN%-8s$PLAIN"

    powercol=$(getcol $airconmode)
    lockcol=$(getcol $modelock)
    printf "${BOLD}Aircon mode:${PLAIN}    $powercol%s$PLAIN" $airconmode
    if [[ $modelock != "n/a" ]]; then
        echo -e " (locked to $lockcol$modelock$PLAIN)"
    else
        echo
    fi
    printf "${BOLD}Current myzone:${PLAIN} %s (zone %s)\n" $airconmyzone $airconmyzoneid
    printf "${BOLD}Tolerance:${PLAIN} %s degrees low, %s degrees high" $tolerance_l $tolerance_h

    echo

    printf "$FORMAT1\n" ""     "Valid" ""      "Set"  "Actual" "Owner" "Proposed                                   "
    printf "$FORMAT2\n" "Zone" "Temp"  "State" "Temp" "Temp"   "Home" "Action                                     "
    for x in ${!zname[@]}; do
        if [[ ${zproblem[$x]} == "too_hot" ]]; then
            actualtempformat="${FORMATHOT}"
        elif [[ ${zproblem[$x]} == "too_cold" ]]; then
            actualtempformat="${FORMATCOLD}"
        elif [[ ${zperfect[$x]} -eq 1 ]]; then
            actualtempformat="${FORMATPERFECT}"
        else
            actualtempformat="${FORMATOK}"
        fi
        if [[ ${airconmode} == "off" ]]; then
            thisstateform="${CLOSEDFORM}"
            thisstate="<off>"
        elif [[ ${zstate[$x]} == "close" ]]; then
            thisstateform="${CLOSEDFORM}"
            thisstate=${zstate[$x]}
        else
            thisstateform="${OPENFORM}"
            thisstate=${zstate[$x]}
        fi
        thiswant="${zwanttemp[$x]}"
        if [[ $thiswant == "n/a" ]]; then
            thiswantcol="$GREY"
        else
            thiswantcol="$PLAIN"
        fi

        # override
        if [[ ${zignore[$x]} -eq 1 ]]; then
            thiswant="ignore"
            thiswantcol="$GREY"
        fi

        if [[ ${zactionfail[$x]} -eq 1 || ${zaction[$x]} == "n/a" ]]; then
            actioncol="$GREY"
        else
            actioncol="$PLAIN"
        fi

        if [[ ${airconmode} == "off" ]]; then
            settempcol="$GREY"
        else
            settempcol="$PLAIN"
        fi

        if [[ $airconmyzoneid == ${zid[$x]} ]]; then
            zonecol="$WHITE$BOLD"
            zonestr="${zname[$x]} (M)"
        else
            zonecol="$PLAIN"
            zonestr="${zname[$x]}"
        fi
        if [[ $constant == ${zname[$x]} ]]; then
            zonestr="${zname[$x]} (C)"
        fi

        if [[ -z ${zowner[$x]} ]]; then
            ownercol="$GREY"
            ownerstr="n/a"
        elif [[ ${zownerhome[$x]} -eq 1 ]]; then
            ownercol="$PLAIN"
            ownerstr="yes"
        else
            ownercol="$GREY"
            ownerstr="no"
        fi

        actionstr="${zaction[$x]}"
        #if [[ ${zaction[$x]} == "n/a" && ${zignore[$x]} -eq 1 ]]; then
        #    actionstr="${actionstr} (zone ignored)"
        #fi

        printf "$zonecol%-16s$PLAIN$thiswantcol%-9s$PLAIN$thisstateform$settempcol%-7s$PLAIN${actualtempformat}${ownercol}%-7s${PLAIN}$actioncol%s$PLAIN\n" "${zonestr}" "${thiswant}" "${thisstate}"  "${zsettemp[$x]}"  "${ztemp[$x]}" "$ownerstr" "${actionstr}"
    done

}

# generate textual description of global problem
function describe_globprob() {
    [[ -z $globprob ]] && return 1;
    if [[ $globprob == too_* ]]; then
        echo "$limit or more zones are ${globprob/_/ }"
    elif [[ $globprob == "not_needed" ]]; then
        echo "The system is on but all zones at optimal temperature"
    elif [[ $globprob == "constant_close" ]]; then
        echo "All other zones are already closed"
    else
        echo "_unknown_globprob_:$globprob"
    fi
    return 0
}

function show_analysis() {  # returns 1 if all good and nothing to show
    local count x ostr
    local amode="normal"

    if [[ $1 == "-t" ]]; then
        mode="telegram"
        shift
    fi
    if [[ $mode != "telegram" ]]; then
        echo -e "${UNDERLINE}Analysis:${PLAIN}"
    fi
    count=0
    for x in ${!zproblem[@]}; do
        znowners=$(wc -w <<< "${zowner[$x]}" | bc)
        zowners=$(sed -r 's/^ +//;s/ +$//;s/ +/, /g' <<< "${zowner[$x]}")
        if [[ ${zproblem[$x]} != "n/a" ]]; then
            if [[ ${zproblem[$x]} == "owner_not_home" ]]; then
                if [[ $znowners -gt 1 ]]; then
                    ostr="owners are"
                else
                    ostr="owner is"
                fi
                echo "- The zone '${zname[$x]}' is open but its $ostr not home (${zowners})"
            elif [[ ${zproblem[$x]} =~ force_ ]]; then
                what=${zproblem[$x]##*_}
                [[ $what == "close" ]] && what="${what}d"
                echo "- The zone '${zname[$x]}' should be $what at this time"
            else
                if [[ ${zownerhome[$x]} -ne 1 ]]; then
                    if [[ $znowners -gt 1 ]]; then
                        append1=", but none of its owners ($zowners) are online"
                    else
                        append1=", but ${zowner[$x]} isn't online"
                    fi
                else
                    append1=""
                fi
                if [[ $constant == ${zname[$x]} ]]; then
                    append2=" (constant zone)"
                else
                    append2=""
                fi
                echo "- The zone '${zname[$x]}' is ${zproblem[$x]/_/ }${append1}${append2}"
            fi
            count=$((count + 1))
        fi
    done

    if [[ -n $globprob ]]; then
        echo "- $(describe_globprob)"
    fi
    if [[ $count -eq 0 && -z $globprob ]]; then
        if [[ $mode != "telegram" ]]; then
            echo -e "${GREEN}All is good!${PLAIN}"
        fi
    fi
    [[ $count -eq 0 && -z $globprob ]] && return 1
    return 0;
}

function killfile_active() { # returns true if killfile will stop us
    local val now
    if [[ ! -f ${KILLFILE} ]]; then
        return 1
    fi
    val=$(head -1 "${KILLFILE}")
    [[ -z $val ]] && return 0
    now=$(date +%s)
    if [[ $val -le $now ]]; then
        # killfile expired
        rm -f "${KILLFILE}"
        if [[ -n $expirenotifyfile ]]; then
            echo "$expirenotifytext" > "$expirenotifyfile"
        fi
        return 1
    fi
    return 0
}

function show_proposed_commands() {
    local str x maxlen count cmdformat fullcmd
    str="Proposed commands"
    echo -e "${UNDERLINE}${str}:${PLAIN}"

    if [[ $nairconcommands -gt 0 ]]; then
        if killfile_active; then
            echo -e "${RED}Not running commands because killfile exists ($KILLFILE)${PLAIN}"
        elif [[ $DOIT -ne 1 ]]; then
            echo -e "${RED}Not running commands because -y not specified${PLAIN}"
        fi
    fi

    maxlen=-99
    for x in ${!airconcmd[@]}; do
        fullcmd="myair $AIRCON_IP ${airconcmd[$x]}"
        thislen=${#fullcmd}
        [[ $thislen -gt $maxlen ]] && maxlen=$thislen
    done

    cmdformat="%-$((maxlen + 3))s"
    count=0
    for x in ${!airconcmd[@]}; do
        fullcmd="myair $AIRCON_IP ${airconcmd[$x]}"
        printf -- "$cmdformat" "$fullcmd"
        [[ -n ${airconcomment[$x]} ]] && printf " $GREEN$BOLD# $PLAIN$GREEN%s$PLAIN\n" "${airconcomment[$x]}" || echo
        count=$((count + 1))
    done
    [[ $count -eq 0 ]] && echo -e "${GREY}n/a${PLAIN}"
}

function combine_commands() {
    local x id2 basefile tfile combinejq jcmd jurl
    combinejq=".[0]"
    if [[ ${#airconjcmd} -eq 0 ]]; then
        return 1
    fi
    basefile=$(mktemp /tmp/$$.json.base.XXXXXX)
    [[ -z $basefile ]] && { error "couldnt create base json file" >&2; exit 1; }

    echo -e "{\n\"aircons\": {\n\"ac1\": {\n\"info\": {\n},\n\"zones\": {\n" >${basefile}

    for x in ${zid[@]}; do
        id2=$(printf "%02d" $x)
        echo "        \"z${id2}\": { }," >>${basefile}
    done
    sed -i '$s/,$//' ${basefile}
    echo -e "}\n}\n}\n}\n" >> ${basefile}

    for x in ${!airconjcmd[@]}; do
        tfile[$x]=$(mktemp /tmp/$$.json.$x.XXXXXX)
        [[ -z ${tfile[$x]} ]] && { error "couldnt create temp file" >&2; exit 1; }
        echo "${airconjcmd[$x]}" >${tfile[$x]}
        combinejq="${combinejq} * .[$((x + 1))]"
    done

    jcmd=$($JQ -s "$combinejq" $basefile ${tfile[@]} )
    [[ $? -ne 0 ]] && { error "couldnt merge json command files " >&2; exit 1; }
    [[ -z $jcmd ]] && { error "got empty merged json command" >&2; exit 1; }
    jurl="${AIRCON_URL}/setAircon?json=$jcmd"

    for x in ${tfile[@]};
        do rm -f "${x}"
    done
    rm -f "$basefile"

    echo "$jurl" | tr -d '\n '
    return 0
}

# note: this function is no longer used
function reword_problem() { #1="problem text"
    local orig="$1" new=""
    if [[ $orig == *" is too "* ]]; then
        new=$(sed -r 's/^([A-Za-z]+) is too ([A-Za-z]+)/the zone "\1" was too \2/' <<<"$orig")
    elif [[ $orig == *" is owner not_home "* ]]; then
        new=$(sed -r 's/^([A-Za-z]+) is .*/the owner of the zone "\1" was not at home/' <<<"$orig")
    elif [[ $orig == *" is force close"* ]]; then
        new=$(sed -r 's/^([A-Za-z]+) is .*/the zone "\1" should be closed at this time/' <<<"$orig")
    elif [[ $orig == *" is n/a"* ]]; then
        ## wrong!   n/a means there is a globprob
        new=$(sed -r 's/^([A-Za-z]+) is .*/the zone "\1" should be the "myzone" at this time/' <<<"$orig")
    else
        new="$orig"
    fi
    new=$(sed 's/&/%26/g' <<<"$new")
    echo "$new"
}

function telegram_send() { #1=msg
    local res msg="$1"
    #action "sending to telegram:  curl -s --data \"text=$msg\" --data \"chat_id=$TELEGRAM_CHAT\" --data \"parse_mode=markdown\" 'https://api.telegram.org/bot'$TELEGRAM_TOKEN'/sendMessage' "
    res=$(curl -s --data "text=$msg" --data "chat_id=$TELEGRAM_CHAT" --data "parse_mode=markdown" 'https://api.telegram.org/bot'$TELEGRAM_TOKEN'/sendMessage' 2>&1)

    if [[ $cronmode -eq 1 ]]; then
        echo "telegram_send:  text=[$msg]"
        echo "telegram_send:  curl=curl -s --data \"text=$msg\" --data \"chat_id=$TELEGRAM_CHAT\" --data \"parse_mode=markdown\" \'https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage\'"
        echo "telegram_send:  res=[$res]"
    fi
    #action "telegram result:  $res"
}

function run_commands() {
    local x tfile combinejq jcmd jurl res jqres
    local thisprob thisfix prevprob
    local botwords="" txt fixnum

    for x in ${!airconcmd[@]}; do
        #echo RUNNING myair $AIRCON_IP ${airconcmd[$x]}

        [[ -n ${airconcomment[$x]} ]] && action "${airconcomment[$x]}"
        influx_insert "INSERT aircon action=\"${airconcomment[$x]}\",comment=\"${airconproblem[$x]}\""
    done

    jurl=$(combine_commands)
    if [[ $? -eq 0 ]]; then
        res=$(curl -s -g "$jurl" 3>/dev/null)
        jqres=$(echo "$res" | $JQ -r '.ack' 2>/dev/null)
        if [[ $jqres != "true" ]]; then
            error "Myair API call failed:"
            echo -e "$RED   curl -s -g $jurl$PLAIN"
            echo -e "$RED   Result:"
            echo "$jqres" | sed 's/_^/       /'
            return 1
        fi
    fi


}


function profile() {
    local diff
    [[ $profiler != 1 ]] && return
    p_last=$p_now
    p_now=$(date +%s)
    diff=$(( p_now - $p_last))
    if [[ -z $p_str ]]; then
        p_str="$*"
    else
        info "+${diff} secs [$*]" >/dev/stderr
        p_str=""
    fi

}

# poplulates glpbals:
#   failedcmds
#   influxrv
function influx_clear() {
    failedcmds=""
    influxrv=0
}

# poplulates glpbals:
#   failedcmds
#   influxrv
function influx_insert() { # $1 == cmd
    local cmd thisrv
    if [[ -z ${influx} ]]; then
        return 1
    fi
    cmd="$1"
    if [[ $DOIT -eq 1 ]]; then
        ${influx} -host "$influxhost" -database "$influxdb" -execute "$cmd"
    else
        echo "${influx} -host "$influxhost" -database $influxdb -execute $cmd"
        thisrv=0
    fi
    thisrv=$?
    influxrv=$((influxrv + $thisrv))
    if [[ $thisrv -ne 0 ]]; then
        failedcmds="$failedcmds$cmd\n"
    fi
}

# poplulates glpbals:
# influx
# influxdb
function influx_init() {  # $1 == dbname
    local dbfound
    influx=$(which influx 2>/dev/null)
    influxdb="$1"
    if [[ $? -ne 0 ]]; then
        error "influx executable not found in path."
        return 1
    fi
    dbfound=$(${influx} -host "$influxhost" -database "$influxdb" -execute "SHOW DATABASES" | grep -w ^${influxdb})
    if [[ -z $dbfound ]]; then
        error "Couldn't find influx database '$influxdb' on host $influxhost"
        return 1
    fi
    influx_clear
    return 0
}

function show_telegram_output() {
    local botwords="" atext fixnum=1 thisprob thisfix

    # get analysis text in telegram mode
    atext=$(show_analysis -t)
    [[ $? -ne 0 ]] && return 1;

    # replace newlines
    atext="$(sed ':begin;$!N;s/\n/%0a/;tbegin' <<<"$atext")"
    # replace ampersands
    atext=$(sed 's/&/%26/g' <<<"${atext}")

    if [[ $? -eq 0 ]]; then
        botwords="I noticed that:%0a"
        botwords="${botwords}${atext}%0a%0a"
        botwords="${botwords}I'm going to do this to fix it:%0a"
        fixnum=1
        for x in ${!airconcmd[@]}; do
            thisprob=${airconproblem[$x]}
            thisfix=$(sed 's/&/%26/g' <<<"${airconcomment[$x]}")
            if [[ $cronmode -eq 1 ]]; then
                echo "telegram_debug:  thisprob=[$thisprob]"
                echo "telegram_debug:  airconcomment[$x]=[${airconcomment[$x]}]"
                echo "telegram_debug:  thisfix=[$thisfix]"
            fi
            botwords="$botwords$(printf '  %d. %s%%0a' $fixnum "$thisfix")"
            fixnum=$((fixnum + 1))
        done
    fi
    [[ -n $botwords && $fixnum -gt 1 ]] && telegram_send "$botwords"
}

p_now=$(date +%s)
p_last=$p_now
p_str=""

CONFIGFILE=${DEFAULT_CONFIGFILE}
KILLFILE=${DEFAULT_KILLFILE}
AIRCON_IP=${DEFAULT_AIRCON_IP}

airconmode="unknown"
airconmyzoneid="n/a"
airconmyzone="n/a"
globprob=""
nairconcommands=0
ntempranges=0
nadj=0
nowners=0
npeople=0
tolerance_l=${DEFAULT_TOLERANCE}
tolerance_h=${DEFAULT_TOLERANCE}
constant=""

DOIT=0
makeconfig=0
modelock="n/a"
cronmode=0
logmode=0  #0=none, 1=csv_file, 2=local influxdb
influxdb=""
influxhost="127.0.0.1"
showwho=0 # 1 = show people, 2 = show owners
limit=$DEFAULTLIMIT
profiler=0
csvfile="$DEFAULT_CSVFILE"
sanitycheck=0
RULEFORMAT=ansi
robtest=0
USETELEGRAM=""
TELEGRAM_FILE=""
TELEGRAM_CHAT=""
TELEGRAM_TOKEN=""

# check for config file option first
if [[ $* == *-f\ * ]]; then
    cf=$(echo "$*" | sed -e 's/.*-f //;s/ .*//')
    if [[ -n $cf ]]; then
        CONFIGFILE="$cf"
    fi
fi

ALLARGS=""
if [[ -e $CONFIGFILE ]]; then
    # load options from file...
    ALLARGS=$(egrep "^options " $CONFIGFILE | sed -e 's/^options //' | tr '\n' ' ')
fi

ALLARGS="$ALLARGS $*"

expirenotifyfile=""
expirenotifytext=""
FAKESTRING=""

optstring="aA:bcD:e:E:f:F:g:hHi:I:k:l:Lo:pmRsSt:T:wWy"
while getopts "$optstring" i $ALLARGS; do
    case "$i" in
        a)
            ARPING=${OPTARG}
            ;;
        A)
            influxdb="$OPTARG"
            ;;
        b)
            RULEDB=1
            ;;
        c)
            enable_cronmode
            ;;
        D)
            influxhost="${OPTARG}"
            ;;
        e)
            expirenotifyfile="$OPTARG"
            ;;
        E)
            expirenotifytext="$OPTARG"
            ;;
        f)
            CONFIGFILE=${OPTARG}
            ;;
        F)
            FAKESTRING="${FAKESTRING} ${OPTARG}"
            ;;
        g)
            USETELEGRAM=1
            TELEGRAM_FILE=${OPTARG}
            ;;
        h)
            usage;
            exit 1;
            ;;
        H)
            RULEFORMAT=html
            ;;
        i)
            AIRCON_IP=${OPTARG}
            ;;
        I)
            logmode=2
            influxdb="$OPTARG"
            ;;
        k)
            KILLFILE=${OPTARG}
            ;;
        l)
            limit=${OPTARG}
            ;;
        L)
            logmode=1
            ;;
        m)
            makeconfig=1
            ;;
        o)
            csvfile="$OPTARG"
            ;;
        p)
            profiler=1
            info "Profiler mode enabled"
            ;;
        R)
            robtest=1
            ;;
        s)
            sanitycheck=1
            ;;
        S)
            sanitycheck=2
            ;;
        t)
            tolerance_l=${OPTARG}
            ;;
        T)
            tolerance_h=${OPTARG}
            ;;
        w)
            showwho=1
            ;;
        W)
            showwho=2
            ;;
        y)
            DOIT=1
            ;;
        *)
            usage;
            exit 1;
            ;;
    esac
done
shift $((OPTIND - 1))

AIRCON_URL="http://${AIRCON_IP}:2025"

if [[ -n $expirenotifyfile && -z $expirenotifytext ]]; then
    error "Cannot use -e option without -E."
    exit 1
fi

if [[ ! -e $ARPING ]]; then
    warn "arping binary '$ARPING' not found, will use ping instead"
fi

if [[ -n $influxdb ]]; then
    influx_init "$influxdb" || exit 1
fi

if [[ $USETELEGRAM -eq 1 ]]; then
    if [[ -z $TELEGRAM_FILE || ! -f $TELEGRAM_FILE ]]; then
        error "Telegram auth file '$TELEGRAM_FILE' doesn't exist."
        exit 1
    fi
    TELEGRAM_TOKEN=$(awk NF $TELEGRAM_FILE | head -1)
    TELEGRAM_CHAT=$(awk NF $TELEGRAM_FILE | tail -1)
    if [[ -z $TELEGRAM_TOKEN ]]; then
        error "Telegram token is empty.  Check that auth file '$TELEGRAM_FILE' first line is token, second line is chat id."
        exit 1
    fi
    if [[ -z $TELEGRAM_CHAT ]]; then
        error "Telegram chat id is empty.  Check that auth file '$TELEGRAM_FILE' first line is token, second line is chat id."
        exit 1
    fi
fi

if [[ $makeconfig -eq 1 ]]; then
    gen_config
    rv=$?
    if [[ $rv -eq 0 ]]; then
        info "A config file for your current aircon setup has been generated here:"
            info "   $CONFIGFILE"
        info "Please review this and update as required."
    fi
    exit $rv
fi

JQ=$(which jq 2>/dev/null)
if [[ $? -ne 0 ]]; then
    error "Can't find jq executable in path."
    exit 1
fi

# Must do this BEFORE parsing the config file, otherwise
# we can't resolve zone names.
get_aircon_info

if [[ -e $CONFIGFILE ]]; then
    if [[ $sanitycheck -ge 1 ]]; then
        parse_config $sanitycheck
        exit $?
    elif ! load_config; then
        error "Config load failed"
        exit 1
    fi
else
    error "Config file $CONFIGFILE doesn't exist."
    exit 1
fi

# fake input for testing
for x in ${FAKESTRING}; do
    fake_name="${x%%:*}"
    fake_wanttemp="${x##*:}"
    fake_idx=-1
    for zi in ${!zname[@]}; do
        if [[ ${zname[zi]^^} == ${fake_name^^} ]]; then
            fake_idx=$zi
            break
        fi
    done
    if [[ ${fake_idx} -eq -1 ]]; then
        error "Unknown zone '${fake_name}' in -f argument '${x}'"
        exit 1;
    fi
    ztemp[$fake_idx]="$fake_wanttemp"
    info "Faking zone '${fake_name}' temp to ${fake_wanttemp}"
done

# ping all hosts in background to populate arp table
#for x in ${devices}; do
#    ping -c1 -w1 -n -q $ip >/dev/null 2>&1 &
#done
#wait

#if [[ $robtest -eq 1 ]]; then
#    for x in ${!zname[@]}; do
#        echo "zone ${zname[$x]} owner is [${zowner[$x]}]"
#    done
#    exit 1
#fi

if [[ $showwho -eq 1 ]]; then
    # get max phone name length
    maxlen=1
    for x in ${pname[@]}; do
        [[ ${#x} -gt $maxlen ]] && maxlen=$((${#x} + 3))
    done
    maxlen=$((maxlen + 1))
    # get a list of all phones
    TFORMAT="${BOLD}${UNDERLINE}%-${maxlen}s%-16s${PLAIN}\n"
    HFORMAT="%-${maxlen}s${GREEN}%-16s${PLAIN}\n"
    AFORMAT="%-${maxlen}s${RED}%-16s${PLAIN}\n"
    echo
    printf "$TFORMAT" "Person" "Availability"
    for x in ${!pname[@]}; do
        if canping ${pdev[$x]}; then
            thisform="$HFORMAT"
            str="At home"
        else
            thisform="$AFORMAT"
            str="Out of the house"
        fi
        printf "$thisform" "${pname[$x]}" "$str"
    done
    echo
    exit 0
elif [[ $showwho -eq 2 ]]; then
    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -en "${GREEN}${BOLD}>> ${PLAIN}${GREEN}Querying zone owners... ${PLAIN}"
    # get max device hostname length
    maxlen=1
    for x in ${ownerhost[@]}; do
        [[ ${#x} -gt $maxlen ]] && maxlen=$((${#x} + 3))
    done
    # get a list of all devices
    TFORMAT="${BOLD}${UNDERLINE}%-${maxlen}s%-16s%s${PLAIN}\n"
    HFORMAT="%-${maxlen}s${GREEN}%-16s${PLAIN}%s\n"
    AFORMAT="%-${maxlen}s${RED}%-16s${PLAIN}%s\n"
    alldevs=$(echo "${ownerhost[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' ')

    n=0
    for x in $alldevs; do
        canping ${x} 2>&1
        pingres[$n]=$?
        n=$((n + 1))
    done

    [[ $cronmode -eq 0 && $logmode -eq 0 ]] && echo -e "${GREEN}${BOLD}ok${PLAIN}"
    echo

    printf "$TFORMAT" "Devices" "Availability" "Zones owned"
    n=0
    for x in $alldevs; do
        if [[ ${pingres[$n]} -eq 0 ]]; then
            thisform="$HFORMAT"
            str="Available"
        else
            thisform="$AFORMAT"
            str="Unavailable"
        fi
        unset mydevs || declare -a mydevs
        for i in ${!ownerzone[@]}; do
            if [[ ${ownerhost[$i]} == *${x}* ]]; then
                mydevs+=("${ownerzone[$i]}")
            fi
        done
        allmydevs=$(echo "${mydevs[@]}" | tr '\n' ' ')
        printf "$thisform" "${x}" "$str" "${allmydevs}"
        n=$((n + 1))
    done
    echo
    exit 0
fi


if [[ $logmode -eq 1 ]]; then
    now=$(date +'%d/%m/%Y %H:%M:%S')
    if [[ ! -e $csvfile ]]; then
        cp /dev/null $csvfile
        echo -n "Date" >>$csvfile
        for x in ${!zname[@]}; do
            echo -n ",${zname[$x]}" >> $csvfile
        done
        echo >> $csvfile
    fi
    echo -n "${now}" >>$csvfile
    for x in ${!zname[@]}; do
        echo -n ",${ztemp[$x]}" >> $csvfile
    done
    echo >> $csvfile
    exit 0
elif [[ $logmode -eq 2 ]]; then
    now=$(date +'%d/%m/%Y %H:%M:%S')

    rv=0
    failedcmds=""
    influx_clear
    for x in ${!zname[@]}; do
        influx_insert "INSERT temperature,room=${zname[$x]} value=${ztemp[$x]}"
    done

    for x in ${!pname[@]}; do
        canping ${pdev[$x]} && ishome=1 || ishome=0
        influx_insert "INSERT attendance,person=${pname[$x]} value=$ishome"
    done
    [[ $airconmode == "off" ]] && pw=0 || pw=1
    influx_insert "INSERT aircon running=$pw"
    #  0= off
    #  1=cool
    #  2=heat
    #  3=dry
    #  4=fan/other
    case "$airconmode" in
        "off") modenum=0;;
        "cool") modenum=1;;
        "heat") modenum=2;;
        "dry") modenum=3;;
        *) modenum=4;;
    esac
    influx_insert "INSERT aircon mode=$modenum"

    if [[ $influxrv -gt 0 ]]; then
        echo -e "${RED}$failedcmds${PLAIN}" | sed -e 's/^/   /'
    fi
    exit ${rv}
fi

generate_actions

if [[ $cronmode -eq 1 ]]; then
    # only show output if we are doing something
    [[ $nairconcommands -ge 1 ]] && showoutput=1 || showoutput=0
else
    showoutput=1
fi


if [[ $showoutput -eq 1 ]]; then
    echo
    show_aircon_status
    echo
    show_analysis
    echo
    show_proposed_commands
    echo
fi

# Actually run the commands
if [[ $DOIT -eq 1 ]]; then
    if ! killfile_active; then
        run_commands
        [[ $cronmode -ne 1 ]] && echo

        if [[ $USETELEGRAM -eq 1 ]]; then
            show_telegram_output
        fi
    fi
fi