#!/bin/sh /etc/rc.common

START=13
STOP=90

USE_PROCD=1
NAME=rg-logger
PROG=/usr/sbin/rg-logger

export LOG_LEVEL
export branch

db_fs="/.nand"
db_dir="/.db"

sys_db_name="sys"
sys_db_tables="backup_state"

ev_db_name="events"
ev_db_tables="source category event log"

data_db_name="data"
data_db_tables="data_working_params data_working_state data_internals data_stats data_hw_status data_cutting_start data_cutting_stop"

db_version_mismatch=0
edb_init_from_scratch=0
ddb_init_from_scratch=0
db_version_needs_initialization=0
force_db_recreation=0
events_db_reset=0
events_db_initialized=0
events_staged_db_path=""

notify_event() {
    if [ -x /sbin/rg-notify.sh ]; then
        /sbin/rg-notify.sh "$@"
    fi
    return 0
}

discard_events_staging() {
    if [ -n "$events_staged_db_path" ]; then
        unlink_db "$events_staged_db_path" || true
    fi
    events_staged_db_path=""
    return 0
}

commit_events_staging() {
    local db_path="${db_dir}/${ev_db_name}.db"
    local staged_db_path="$events_staged_db_path"

    [ -n "$staged_db_path" ] || return 0
    archive_db "$ev_db_name" || return 1
    mv "$staged_db_path" "$db_path" || return 1
    events_staged_db_path=""
    write_catalog_revision || return 1
}

data_working_params_patch() {
    local db_file_path=$1
    local db_table_name=$2

    [ "$branch" = "devel" ] || return 0
    sqlite3 "$db_file_path" "alter table $db_table_name add power INTEGER;" > /dev/null 2>&1
}

prepare_db_tables() {
    local db_name=$1; shift
    local db_tables=$@
    local db_path="${db_dir}/${db_name}.db"
    local rc t ts

    ts=$(date +%s)

    # This will set upper level variable to notify about DB initialization from scratch (if needed)
    init_from_scratch=$force_db_recreation

    [ -f "$db_path" ] || init_from_scratch=1

    if [ $init_from_scratch -eq 0 ]; then
        last_integrity_check_ts=$(cat "$db_dir/LAST_INTEGRITY_CHECK-$db_name" 2>/dev/null || true)
        if [ -z "$last_integrity_check_ts" ] || [ $((ts - last_integrity_check_ts)) -gt $integrity_check_interval ]; then
            # perform integrity check if it was not done in the last $integrity_check_interval seconds
            mylog debug "Performing integrity check for $db_name DB"
            if check_db_integrity "$db_name"; then
                rc=0
            else
                rc=$?
            fi
            if [ $rc -ne 0 ]; then
                mylog error "Database integrity check failed: $db_name [$db_path]"
                # integrity check failed, try to recover by recreating DB from scratch
                init_from_scratch=1
            fi
            echo $ts > "$db_dir/LAST_INTEGRITY_CHECK-$db_name"
        fi
    fi

    if [ $init_from_scratch -eq 0 ]; then
        rc=0
        for t in $db_tables; do
            mylog debug "Checking table $t in $db_name DB"
            if check_db_table "$db_path" "$t"; then
                rc=0
            else
                rc=$?
            fi
            [ $rc -ne 0 ] && {
                mylog error "Database table check failed: $db_name.$t [$db_path]"
                init_from_scratch=1

                # Notify only when DB version is the same,
                # otherwise it is not guaranteed that DB structure is the same
                # as expected by the code, and integrity check will fail
                [ $db_version_mismatch -eq 0 ] && {
                    # {db_name}: table {table_name} is corrupted
                    notify_event I0001 C0003 "$db_name^$t"
                }
                break
            }
        done
    fi

    # Content revisions migrate independently of the physical DB schema.
    if [ "$db_name" = "events" ] && [ $init_from_scratch -eq 0 ] &&
        [ "$events_db_reset" -eq 0 ]; then
        if events_catalog_revision_matches "$db_path"; then
            return 0
        fi
        if events_catalog_has_rows "$db_path"; then
            migrate_events_catalog "$db_path" && return 0
            mylog error "Events catalog migration failed or unsupported: $db_path"
            return 1
        fi
        init_from_scratch=1
    fi

    [ "$db_name" = "events" ] && [ "$events_db_reset" -eq 1 ] &&
        init_from_scratch=1
    [ $init_from_scratch -eq 0 ] && return 0

    # DB check failed
    [ $db_version_mismatch -eq 0 ] && {
        # {db_name}: DB structure check failed
        notify_event I0001 C0002 "$db_name"
    }

    # Recreate events DB in a staging file. The old DB remains at its path
    # until structure creation and the one-session catalog import succeed.
    if [ "$db_name" = "events" ]; then
        local staged_db_path="${db_path}.new.$$"
        db_path_override="$staged_db_path"
        unlink_db "$staged_db_path" || return 1
        if create_db_structure "$db_name" $db_tables; then
            rc=0
        else
            rc=$?
        fi
        if [ $rc -eq 0 ]; then
            if fill_events_catalog "$staged_db_path"; then
                rc=0
            else
                rc=$?
            fi
        fi
        unset db_path_override
        [ $rc -ne 0 ] && {
            unlink_db "$staged_db_path"
            mylog error "Events catalog initialization failed"
            # {db_name}: error filling table {table_name} with initial data
            notify_event I0001 C0006 "events^catalog"
            return $rc
        }

        events_staged_db_path="$staged_db_path"
        events_db_initialized=1
        return 0
    fi

    if [ "$events_db_reset" -eq 1 ] && [ "$force_db_recreation" -eq 0 ] &&
        [ "$init_from_scratch" -eq 1 ]; then
        mylog error "Non-events DB is not ready during events-only migration"
        return 1
    fi

    # recreate non-events DB from scratch

    archive_db "$db_name" || return 1
    unlink_db "$db_path" || return 1

    if create_db_structure "$db_name" $db_tables; then
        rc=0
    else
        rc=$?
    fi
    [ $rc -ne 0 ] && {
        mylog error "Database initialization error: $db_name [$db_path]"
        # {db_name}: database initialization error
        notify_event I0001 C0005 "$db_name"
        return $rc
    }

    # fill tables with initial data (if any)
    #
    for table_name in $db_tables; do
        if fill_table "$db_path" "$db_name" "$table_name"; then
            rc=0
        else
            rc=$?
        fi
        [ $rc -ne 0 ] && {
            mylog error "Error filling table $table_name for db $db_name"
            # {db_name}: error filling table {table_name} with initial data
            notify_event I0001 C0006 "$db_name^$table_name"
            return $rc
        }
    done

    return 0
}

prepare_databases() {
    local rc
    local db_fs_mounted
    local init_from_scratch=0
    local cur_db_ver

    db_version_mismatch=0
    db_version_needs_initialization=0
    force_db_recreation=0
    events_db_reset=0
    events_db_initialized=0
    events_staged_db_path=""

    [ -d "$db_dir" ] || {
        mylog debug "DB directory $db_dir does not exist, trying to create it"
        db_fs_mounted=$(mount | grep $db_fs)
        if [ -n "$db_fs_mounted" ]; then
            if [ ! -d $db_fs/db ]; then
                mkdir $db_fs/db
            fi
            ln -sf $db_fs/db "$db_dir"
        else
            mkdir -p $db_dir
        fi
    }

    cur_db_ver=$(cat "$db_dir/VERSION" 2>/dev/null || true)

    if [ "X$cur_db_ver" != "X$db_version" ]; then
        mylog warning "DB version mismatch: expected $db_version, actual $cur_db_ver"
        # Supported migrations preserve data; failed ones archive before recreation.
        notify_event I0001 C0001
        db_version_mismatch=1
    fi

    migrate_db_version "$cur_db_ver" || {
        mylog error "DB migration from $cur_db_ver to $db_version failed; preserving databases"
        return 1
    }

    prepare_db_tables $sys_db_name $sys_db_tables
    rc=$?
    [ $rc -ne 0 ] && {
        mylog error "Sys DB is not ready"
        discard_events_staging
        return 1
    }

    prepare_db_tables $ev_db_name $ev_db_tables
    rc=$?
    [ $rc -ne 0 ] && {
            mylog error "Events DB is not ready"
            discard_events_staging
            return 1
    }
    [ "$events_db_initialized" -eq 1 ] && {
        # Event storage initialized
        notify_event I0001 I0001
        edb_init_from_scratch=1
    }

    prepare_db_tables $data_db_name $data_db_tables
    rc=$?
    [ $rc -ne 0 ] && {
            mylog error "Data DB is not ready"
            discard_events_staging
            return 1
    }
    [ $init_from_scratch -eq 1 ] && {
        # Data storage initialized
        notify_event I0001 I0002
        ddb_init_from_scratch=1
    }

    commit_events_staging || {
        mylog error "Unable to commit staged events database"
        discard_events_staging
        return 1
    }

    if [ "$db_version_needs_initialization" -eq 1 ]; then
        write_db_version || {
            mylog error "Unable to record database version $db_version"
            return 1
        }
    fi

    events_db_reset=0

    return 0
}

service_triggers()
{
    procd_add_reload_trigger "rg-logger"
}

start_service() {
    [ -r /lib/rg/package-update.sh ] || return 1
    . /lib/rg/package-update.sh
    rg_package_update_allowed || return 1

    local rc spool_dir integrity_check_interval elog_size dlog_size
    local logging_level pragma_synchronous locale_code have_nand

    config_load "rg-logger"
    config_get elog_size options event_log_size 2048
    config_get dlog_size options data_log_size 4096
    config_get logging_level options logging_level 4
    config_get pragma_synchronous options pragma_synchronous 0
    config_get locale_code options locale_code "en"
    config_get integrity_check_interval options integrity_check_interval 172800
    config_get have_nand system have_nand 0

    # will be used in mylog() function to filter messages by log level
    LOG_LEVEL=$logging_level

    [ $pragma_synchronous -lt 0 ] && pragma_synchronous=0
    [ $pragma_synchronous -gt 3 ] && pragma_synchronous=3

    [ $logging_level -lt 0 ] && logging_level=0
    [ $logging_level -gt 7 ] && logging_level=7

    [ "$action" = "boot" ] && {
        # system start
        notify_event S0005 I0001
    }
    . /lib/rg/common.sh
    . /lib/rg/rg-logger.sh

    get_cc_version ver rel branch
    if [ -z "$branch" ]; then branch="production"; fi
    db_version="${branch}-16"

    prepare_databases
    rc=$?
    [ $rc -ne 0 ] && {
        mylog error "DB is not ready"
        return 1
    }

    spool_dir="/.data/rg-logger-spool"
    if [ $have_nand -eq 1 ]; then
        spool_dir="/.nand/rg-logger-spool"
        mkdir -p $spool_dir
    fi

    procd_open_instance
    procd_set_param command "$PROG" -E ${elog_size} -D ${dlog_size} -S "$spool_dir" -d ${logging_level}
    [ $pragma_synchronous -ne 0 ] && procd_append_param command -s $pragma_synchronous
    [ -n "$locale_code" ] && procd_append_param command -L $locale_code

    procd_set_param respawn
    procd_set_param term_timeout 45
    procd_close_instance
}

reload_service() {
    [ -r /lib/rg/package-update.sh ] || return 1
    . /lib/rg/package-update.sh
    rg_package_update_allowed || return 1

    start
}

stop() {
    service_stop $PROG
}

reload() {
    service_reload $PROG
}
