#!/usr/bin/env bash
# Comprehensive tests for the log script
# Tests all log functions: levels, output, live logging, clear, capture

#export PS4='\e[90m+${LINENO} in ${#BASH_SOURCE[@]}>${FUNCNAME[0]}:${BASH_SOURCE[@]##*/} \e[0m'
#set -x

level=$1
if [ -z "$level" ]; then
  level=1
else
  shift
fi
echo "starting: ${BASH_SOURCE[@]##*/} <LOG_LEVEL=$level>"

source this
source test.suite
source log

log.level $level

# Test temp files
TEST_LOG_DEVICE="/tmp/test.log.device.$$"
TEST_LOG_LIVE="/tmp/test.log.live.$$"
ORIGINAL_LOG_LEVEL=$LOG_LEVEL
ORIGINAL_LOG_DEVICE=$LOG_DEVICE
ORIGINAL_LOG_LIVE=$LOG_LIVE
ORIGINAL_STEP_DEBUG=$STEP_DEBUG

# Disable STEP_DEBUG to prevent test blocking
export STEP_DEBUG=OFF

# Cleanup function
cleanup_test_files() {
  rm -f "$TEST_LOG_DEVICE" 2>/dev/null
  rm -f "$TEST_LOG_LIVE" 2>/dev/null
  export LOG_LEVEL=$ORIGINAL_LOG_LEVEL
  export LOG_DEVICE=$ORIGINAL_LOG_DEVICE
  export LOG_LIVE=$ORIGINAL_LOG_LIVE
  export STEP_DEBUG=$ORIGINAL_STEP_DEBUG
}

# Cleanup before tests
cleanup_test_files
touch "$TEST_LOG_DEVICE"
touch "$TEST_LOG_LIVE"

# ============================================================================
# T1: Test log.level sets LOG_LEVEL
# ============================================================================
test.case - "T1: log.level sets LOG_LEVEL" \
  log.level 5

if [ "$LOG_LEVEL" = "5" ]; then
  create.result 0 "LOG_LEVEL=5"
else
  create.result 1 "LOG_LEVEL=$LOG_LEVEL, expected 5"
fi
expect 0 "LOG_LEVEL=5" "log.level sets LOG_LEVEL correctly"

# ============================================================================
# T2: Test log.level without args returns current level
# ============================================================================
export LOG_LEVEL=3
test.case - "T2: log.level without args shows current level" \
  echo "testing"

OUTPUT=$(log.level 2>/dev/null | grep "LOG_LEVEL")
if echo "$OUTPUT" | grep -q "LOG_LEVEL=3"; then
  create.result 0 "Shows LOG_LEVEL=3"
else
  create.result 1 "Output: $OUTPUT"
fi
expect 0 "Shows LOG_LEVEL=3" "log.level shows current level"

# ============================================================================
# T3: Test log.device sets LOG_DEVICE
# ============================================================================
test.case - "T3: log.device sets LOG_DEVICE" \
  log.device "$TEST_LOG_DEVICE"

if [ "$LOG_DEVICE" = "$TEST_LOG_DEVICE" ]; then
  create.result 0 "LOG_DEVICE set"
else
  create.result 1 "LOG_DEVICE=$LOG_DEVICE"
fi
expect 0 "LOG_DEVICE set" "log.device sets LOG_DEVICE correctly"

# ============================================================================
# T4: Test console.log outputs at level > 2
# ============================================================================
export LOG_LEVEL=3
export LOG_DEVICE="$TEST_LOG_DEVICE"
> "$TEST_LOG_DEVICE"  # Clear file

test.case - "T4: console.log outputs at level 3" \
  console.log "test message console"

if grep -q "test message console" "$TEST_LOG_DEVICE"; then
  create.result 0 "Message logged"
else
  create.result 1 "Message not found in $TEST_LOG_DEVICE"
fi
expect 0 "Message logged" "console.log outputs at level > 2"

# ============================================================================
# T5: Test console.log silent at level <= 2
# ============================================================================
export LOG_LEVEL=2
> "$TEST_LOG_DEVICE"

test.case - "T5: console.log silent at level 2" \
  console.log "should not appear"

if grep -q "should not appear" "$TEST_LOG_DEVICE"; then
  create.result 1 "Message appeared when it shouldn't"
else
  create.result 0 "Correctly silent"
fi
expect 0 "Correctly silent" "console.log silent at level <= 2"

# ============================================================================
# T6: Test error.log outputs at level > 0
# ============================================================================
export LOG_LEVEL=1
> "$TEST_LOG_DEVICE"

test.case - "T6: error.log outputs at level 1" \
  error.log "test error message"

if grep -q "ERROR" "$TEST_LOG_DEVICE"; then
  create.result 0 "Error logged"
else
  create.result 1 "Error not found"
fi
expect 0 "Error logged" "error.log outputs at level > 0"

# ============================================================================
# T7: Test warn.log outputs at level > 1
# ============================================================================
export LOG_LEVEL=2
> "$TEST_LOG_DEVICE"

test.case - "T7: warn.log outputs at level 2" \
  warn.log "test warning message"

# warn.log outputs to stdout, not LOG_DEVICE
OUTPUT=$(warn.log "test warning" 2>&1)
if echo "$OUTPUT" | grep -q "WARNING"; then
  create.result 0 "Warning logged"
else
  create.result 1 "Warning not found: $OUTPUT"
fi
expect 0 "Warning logged" "warn.log outputs at level > 1"

# ============================================================================
# T8: Test important.log outputs at level > 1
# ============================================================================
export LOG_LEVEL=2
> "$TEST_LOG_DEVICE"

test.case - "T8: important.log outputs at level 2" \
  important.log "test important message"

if grep -q "IMPORTANT" "$TEST_LOG_DEVICE"; then
  create.result 0 "Important logged"
else
  create.result 1 "Important not found"
fi
expect 0 "Important logged" "important.log outputs at level > 1"

# ============================================================================
# T9: Test debug.log outputs at level > 4
# ============================================================================
export LOG_LEVEL=5
> "$TEST_LOG_DEVICE"

test.case - "T9: debug.log outputs at level 5" \
  debug.log "test debug message"

if grep -q "test debug message" "$TEST_LOG_DEVICE"; then
  create.result 0 "Debug logged"
else
  create.result 1 "Debug not found"
fi
expect 0 "Debug logged" "debug.log outputs at level > 4"

# ============================================================================
# T10: Test debug.log silent at level <= 4
# ============================================================================
export LOG_LEVEL=4
> "$TEST_LOG_DEVICE"

test.case - "T10: debug.log silent at level 4" \
  debug.log "should not appear debug"

if grep -q "should not appear debug" "$TEST_LOG_DEVICE"; then
  create.result 1 "Debug appeared when it shouldn't"
else
  create.result 0 "Correctly silent"
fi
expect 0 "Correctly silent" "debug.log silent at level <= 4"

# ============================================================================
# T11: Test success.log outputs at level > 2
# ============================================================================
export LOG_LEVEL=3
> "$TEST_LOG_DEVICE"

test.case - "T11: success.log outputs at level 3" \
  success.log "test success message"

if grep -q "SUCCESS" "$TEST_LOG_DEVICE"; then
  create.result 0 "Success logged"
else
  create.result 1 "Success not found"
fi
expect 0 "Success logged" "success.log outputs at level > 2"

# ============================================================================
# T12: Test silent.log outputs at level > 2
# ============================================================================
export LOG_LEVEL=3
> "$TEST_LOG_DEVICE"

test.case - "T12: silent.log outputs at level 3" \
  silent.log "test silent message"

if grep -q "test silent message" "$TEST_LOG_DEVICE"; then
  create.result 0 "Silent logged"
else
  create.result 1 "Silent not found"
fi
expect 0 "Silent logged" "silent.log outputs at level > 2"

# ============================================================================
# T13: Test log.live.file sets LOG_LIVE
# ============================================================================
test.case - "T13: log.live.file sets LOG_LIVE" \
  log.live.file "$TEST_LOG_LIVE"

if [ "$LOG_LIVE" = "$TEST_LOG_LIVE" ]; then
  create.result 0 "LOG_LIVE set"
else
  create.result 1 "LOG_LIVE=$LOG_LIVE"
fi
expect 0 "LOG_LIVE set" "log.live.file sets LOG_LIVE correctly"

# ============================================================================
# T14: Test LOG_LIVE output when set
# ============================================================================
export LOG_LIVE="$TEST_LOG_LIVE"
export LOG_LEVEL=3
> "$TEST_LOG_LIVE"

test.case - "T14: LOG_LIVE receives output when set" \
  console.log "live test message"

if grep -q "live test message" "$TEST_LOG_LIVE"; then
  create.result 0 "Live message logged"
else
  create.result 1 "Live message not found"
fi
expect 0 "Live message logged" "LOG_LIVE receives log output"

# ============================================================================
# T15: Test log.clear.liveLog clears file
# ============================================================================
echo "some content to clear" > "$TEST_LOG_LIVE"

test.case - "T15: log.clear.liveLog clears file" \
  log.clear.liveLog "$TEST_LOG_LIVE"

# File should have clear marker but not old content
if grep -q "some content to clear" "$TEST_LOG_LIVE"; then
  create.result 1 "Old content still present"
elif grep -q "clear log" "$TEST_LOG_LIVE"; then
  create.result 0 "File cleared with marker"
else
  create.result 0 "File cleared"
fi
expect 0 "File cleared with marker" "log.clear.liveLog clears file"

# ============================================================================
# T16: Test stop.log outputs at level > 3
# ============================================================================
export LOG_LEVEL=4
> "$TEST_LOG_DEVICE"

test.case - "T16: stop.log outputs at level 4" \
  stop.log "test breakpoint"

# Reset STEP_DEBUG after stop.log sets it
export STEP_DEBUG=OFF

if grep -q "BREAKPOINT" "$TEST_LOG_DEVICE"; then
  create.result 0 "Breakpoint logged"
else
  create.result 1 "Breakpoint not found"
fi
expect 0 "Breakpoint logged" "stop.log outputs at level > 3"

# ============================================================================
# T17: Test problem.log outputs at level > 1
# ============================================================================
export LOG_LEVEL=2

test.case - "T17: problem.log outputs at level 2" \
  echo "testing problem.log"

OUTPUT=$(problem.log "test problem" 2>&1)
# Reset STEP_DEBUG after problem.log sets it
export STEP_DEBUG=OFF

if echo "$OUTPUT" | grep -q "PROBLEM"; then
  create.result 0 "Problem logged"
else
  create.result 1 "Problem not found: $OUTPUT"
fi
expect 0 "Problem logged" "problem.log outputs at level > 1"

# ============================================================================
# T18: Test error.details.log outputs at level > 0
# ============================================================================
export LOG_LEVEL=1

test.case - "T18: error.details.log outputs at level 1" \
  echo "testing error.details.log"

OUTPUT=$(error.details.log "detailed error info" 2>&1)
if echo "$OUTPUT" | grep -q "detailed error info"; then
  create.result 0 "Details logged"
else
  create.result 1 "Details not found"
fi
expect 0 "Details logged" "error.details.log outputs at level > 0"

# ============================================================================
# T19: Test log.level reset toggles levels
# ============================================================================
export LOG_LEVEL=3
export LOG_LEVEL_RESET=5

test.case - "T19: log.level reset toggles levels" \
  log.level reset

if [ "$LOG_LEVEL" = "5" ] && [ "$LOG_LEVEL_RESET" = "3" ]; then
  create.result 0 "Levels toggled"
else
  create.result 1 "LOG_LEVEL=$LOG_LEVEL, LOG_LEVEL_RESET=$LOG_LEVEL_RESET"
fi
expect 0 "Levels toggled" "log.level reset toggles between levels"

# ============================================================================
# T20: Test test.console.log outputs at level > 0
# ============================================================================
export LOG_LEVEL=1
> "$TEST_LOG_DEVICE"

test.case - "T20: test.console.log outputs at level 1" \
  test.console.log "test console at level 1"

if grep -q "test console at level 1" "$TEST_LOG_DEVICE"; then
  create.result 0 "Test console logged"
else
  create.result 1 "Test console not found"
fi
expect 0 "Test console logged" "test.console.log outputs at level > 0"

# ============================================================================
# T21: Test test.success.log outputs at level > 0
# ============================================================================
export LOG_LEVEL=1

test.case - "T21: test.success.log outputs at level 1" \
  echo "testing test.success.log"

OUTPUT=$(test.success.log "test success at level 1" 2>&1)
if echo "$OUTPUT" | grep -q "SUCCESS"; then
  create.result 0 "Test success logged"
else
  create.result 1 "Test success not found"
fi
expect 0 "Test success logged" "test.success.log outputs at level > 0"

# ============================================================================
# T22: Test log.init.colors loads colors
# ============================================================================
test.case - "T22: log.init.colors loads color config" \
  log.init.colors

# Should not error if CONFIG_PATH is set
if [ -n "$CONFIG_PATH" ]; then
  create.result 0 "Colors initialized"
else
  create.result 1 "CONFIG_PATH not set"
fi
expect 0 "Colors initialized" "log.init.colors loads without error"

# ============================================================================
# T23: Test clear.resultFiles clears result files
# ============================================================================
echo "test content" > ~/config/result.txt 2>/dev/null
echo "test error" > ~/config/error.txt 2>/dev/null

test.case - "T23: clear.resultFiles clears result files" \
  clear.resultFiles

if [ ! -f ~/config/result.txt ] || [ ! -s ~/config/result.txt ]; then
  create.result 0 "Result files cleared"
else
  create.result 1 "Result files not cleared"
fi
expect 0 "Result files cleared" "clear.resultFiles removes result/error files"

# ============================================================================
# Cleanup
# ============================================================================
cleanup_test_files

test.suite.save.results