squashDevice(){
  echo "$(mount | grep -F squashfs | head -n1 | awk '{print $1;}')"
}

umountSquash(){
  mountpoint -q "$squashfs" && umount "$squashfs"
}

mountSquash(){
  [ -d "$(dirname "$squashfs")" ] || return 1
  umountSquash
  mkdir -p "$squashfs"
  local sdev="$(squashDevice)"
  [ -z "$sdev" ] && return 1
  mount -o ro,noatime "$sdev" "$squashfs"
}

mount_base(){
  mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs "$mountpoint/var"
  mkdir -p "$mountpoint/var/lib"
  mount -o defaults,nosuid,nodev,noatime /dev/nandc "$mountpoint/var/lib"
  mountSquash
}

umount_base(){
  sync
  umountSquash
  umount "$mountpoint/var/lib"
  umount "$mountpoint/var"
}

remove_old(){
  [ -d "$1" ] || return 1
  [ -f "$modpath/script/removed" ] || return 0
  local basepath="$1"
  source "$modpath/script/removed"
}

mod_repair_etc(){
  [ -d "$rootfs" ] || return 0
  remove_old "$rootfs"

  local etc="$temppath/etc"
  rm -rf "$etc"
  mkdir -p "$etc"
  copy "$mountpoint/etc/" "$etc/"
  if [ "$1" == "full" ]; then
    rm -f "$modpath/rootfs/etc/preinit.d/p0000_config"
    copy "$modpath/rootfs/etc/" "$etc/"
  else
    copy "$rootfs/etc/inittab" "$etc/inittab"
  fi
  copy "$etc/" "$rootfs/etc/"
  rm -rf "$etc"
}

mod_repair_modules(){
  [ -d "$mountpoint/lib/modules/$(uname -r)" ] && restore "/lib/modules/$(uname -r)/"
}

mount_move(){
  local tmpmount="/$2"
  if [ "$1" == "l" ]; then
    mountpoint -q "$mountpoint$tmpmount" || return 1
    mkdir -p "$tmpmount"
    mount --move "$mountpoint$tmpmount" "$tmpmount"
  else
    mountpoint -q "$tmpmount" || return 1
    mount --move "$tmpmount" "$mountpoint$tmpmount"
    rmdir --ignore-fail-on-non-empty "$tmpmount"
  fi
}

remount_root(){
  mount_move l media
  mount_move l var

  umount "$mountpoint"
  local loopfile="/var${1##$mountpoint/var}"
  [ -f "$loopfile" ] || loopfile="/media${1##$mountpoint/media}"
  if ! mount -o loop,ro,noatime "$loopfile" "$mountpoint"; then
    local preinitf="/${preinit##$mountpoint/}"
    local preinit="$preinitf"
    cfg_firmware="_nand_"
    save_config
    shutdown
  fi

  mount_move r var
  mount_move r media
}

checkFirmware(){
  [ -f "$1" ] || return 1
  [ "$(hexdump -e '1/4 "%u"' -s 0 -n 4 "$1")" == "1936814952" ] || return 1
  return 0
}

currentFirmware(){
  local firmware="$(losetup | awk '{print $3'})"
  if ! [ -z "$firmware" ]; then
    echo "$firmware"
    return 0
  fi
  if [ -b "/dev/mapper/root-crypt" ]; then
    echo "_nand_"
    return 0
  fi
  return 1
}

loadFirmware(){
  [ -z "$(mount | grep -F loop0)" ] || return 1

  local firmware="$mountpoint$cfg_firmware"
  if ! checkFirmware "$firmware"; then
    [ "$cfg_firmware" == "auto" ] || return 0
    [ -d "$firmwarepath" ] || return 0
    firmware="$(find "$firmwarepath" -type f -name "*.hsqs" | sort | head -n 1)"
  fi
  checkFirmware "$firmware" || return 0

  mod_repair_modules
  umountSquash
  remount_root "$firmware"
  cryptsetup close root-crypt
  mountSquash
  if [ ! -d "$mountpoint/lib/modules/$(uname -r)" ]; then
    if [ -d "$rootfs/lib/modules/$(uname -r)" ]; then
      overmount "/lib/modules"
    else
      echo "no modules for loaded kernel $(uname -r)"
    fi
  fi
}

shutdown(){
  echo "The system is going down NOW!"
  sync
  umount -a -r 2>/dev/null
  poweroff -f
  while :;do sleep 1;:;done
}

reboot(){
  echo "Restarting system."
  sync
  umount -a -r 2>/dev/null
  /bin/reboot -f
  while :;do sleep 1;:;done
}

early_getty(){
  cd "$modpath/transfer"
  getty -ni 115200 ttyS0 -l /bin/sh
  cd /
}

copy(){
  # we must create target directory
  local dirname="$(dirname "$2")"
  mkdir -p "$dirname"
  rsync -ac "$1" "$2"
}

copy_mask(){
  # this function is unsafe, avoid spaces in filenames!
  local dirname="$(dirname "$2")"
  mkdir -p "$dirname"
  rsync -ac $1 "$2"
}

restore(){
  if mountpoint -q "$squashfs" && [ -e "$squashfs$1" ]; then
    copy "$squashfs$1" "$rootfs$1"
  else
    copy "$mountpoint$1" "$rootfs$1"
  fi
}

mount_bind(){
  if mountpoint -q "$2"; then
    umount "$2" || umount -f "$2"
  fi
  mount -o bind "$1" "$2"
}

overmount(){
  if [ "$#" == "1" ]; then
    echo "overmounting $1"
    mount_bind "$rootfs$1" "$mountpoint$1" && return 0
  fi
  if [ "$#" == "2" ]; then
    echo "overmounting $1 on $2"
    mount_bind "$rootfs$1" "$mountpoint$2" && return 0
  fi
  echo "overmounting failed"
  return 1
}

containsGames(){
  [ -d "$1" ] || return 1
  [ -z "$(cd "$1";ls CLV-* 2>/dev/null)" ] && return 1
  return 0
}

linkGames(){
  local games="$mountpoint/media/$modname/games${1##$rootfs$gamepath}"
  [ -d "$games" ] || games="$installpath/games${1##$rootfs$gamepath}"
  [ -d "$games" ] || games="$1"
  games="${games##$mountpoint}"
  rm -f "$mountpoint/var/games"
  ln -s "$games" "$mountpoint/var/games"
  return 0
}

softwareCheck(){
  sftype="nes"
  sfregion="usa"
  [ "$(cat "$mountpoint/etc/clover/boardtype")" == "dp-shvc" ] && sftype="snes"
  [ "$(cat "$mountpoint/etc/clover/REGION")" == "JPN" ] && sfregion="jpn"
  [ "$(cat "$mountpoint/etc/clover/REGION")" == "EUR" ] && sfregion="eur"

  local feck="$mountpoint/var/lib/clover/profiles/0/home-menu/save/system-save.json"
  if [ "$sftype" == "snes" ]; then
    gamepath="/usr/share/games"
    [ -f "$feck" ] && mv -f "$feck" "$feck.nes"
    [ -d "$feck.snes" ] && rm -rf "$feck" && mv "$feck.snes" "$feck"
  else
    gamepath="/usr/share/games/nes/kachikachi"
    [ -d "$feck" ] && rm -rf "$feck.snes" && mv "$feck" "$feck.snes"
    [ -f "$feck.nes" ] && mv -f "$feck.nes" "$feck"
  fi
  
  rm -f "$mountpoint/var/saves"
  ln -s "/var/lib/clover/profiles/0" "$mountpoint/var/saves"
}

repair_fonts(){
  if [ "$sftype" == "nes" ]; then
    mkdir -p "$1" || return 1
    [ ! -f "$1/title.fnt" ] && (cp $rootfs$gamepath/title.fnt "$1" || cp $squashfs$gamepath/title.fnt "$1")
    [ ! -f "$1/copyright.fnt" ] && (cp $rootfs$gamepath/copyright.fnt "$1" || cp $squashfs$gamepath/copyright.fnt "$1")
  fi
}

repair_games(){
  [ -w "$1" ] || return 0
  local usesymlink=''
  ln -s / "$1/symlinktest" && rm "$1/symlinktest" && usesymlink='y'
  
  ls -1 "$squashfs$gamepath" | grep CLV- | while read code
  do
    local gamedir="$1/$code"
    local squashgamedir="$squashfs$gamepath/$code"
    
    [ -d "$gamedir" ] || continue
    
    if [ ! -f "$gamedir/$code.desktop" ]; then
      cp "$squashgamedir/$code.desktop" "$gamedir/"
      [ "$sftype" == "nes" ] && \
        sed -i -e 's#/usr/bin/clover-kachikachi#/bin/clover-kachikachi-wr#g' "$gamedir/$code.desktop"
      [ "$sftype" == "snes" ] && \
        sed -i -e 's#/usr/bin/clover-canoe-shvc#/bin/clover-canoe-shvc-wr#g' "$gamedir/$code.desktop"
    fi
    
    [ -d "$gamedir/autoplay/" ] && ([ "$(ls -A "$gamedir/autoplay/")" ] || rm -r "$gamedir/autoplay/")
    [ -d "$gamedir/pixelart/" ] && ([ "$(ls -A "$gamedir/pixelart/")" ] || rm -r "$gamedir/pixelart/")
    
    find "$squashgamedir" -maxdepth 1 | sed -n '1!p' | while read squashfile
    do
      if [ "$usesymlink" == "y" ]; then
        ln -s "${squashfile##$mountpoint}" "$gamedir/" > /dev/null 2>&1
      else
        rsync -a --ignore-existing "$squashfile" "$gamedir/" > /dev/null 2>&1
      fi
    done
  done
  sync
  return 0
}

overmount_games(){
  local menu_code="000"
  [ -f "$installpath/menu" ] && menu_code="$(cat "$installpath/menu")"
  containsGames "$rootfs$gamepath/$menu_code" || menu_code=""
  echo "menu code: $menu_code"
  if containsGames "$rootfs$gamepath/$menu_code"; then
    overmount "$gamepath/$menu_code" "$gamepath" && repair_games "$rootfs$gamepath/$menu_code" && linkGames "$rootfs$gamepath/$menu_code" && return 0
  else
    echo "no romz found at: $rootfs$gamepath/$menu_code"
  fi
  linkGames "$gamepath"
  return 1
}

uilist(){
  lsof -n | grep -F "/dev/fb0" | awk '{print $1}' | sort -u
}

uikill(){
  [ -z "$1" ] && return 1
  uilist | xargs -r kill -s "$1"
}

uistop(){
  killall -s KILL clover-mcp 1>/dev/null 2>&1
  uikill TERM
}

uistart(){
  uistop
  sh "/etc/init.d/S81clover-mcp" start
}

uipause(){
  uikill STOP
}

uiresume(){
  uikill CONT
}

gameover(){
  poweroff
}

printSoftwareInfo(){
  echo "software=$sftype"
  echo "region=$sfregion"
}

showImage(){
  image="$(eval echo "$1")"
  [ -f "$image" ] || image="$rootfs$1"
  [ -f "$image" ] || image="$squashfs$1"
  [ -f "$image" ] || return 1
  decodepng "$image" > "/dev/fb0" &
  return 0
}

hwmon(){
  cat "/sys/devices/virtual/hwmon/hwmon1/temp1_input"
}