#!/usr/bin/env bash

# ─< Check if the given command exists silently >─────────────────────────────────────────
command-exists() {
  command -v "$@" >/dev/null 2>&1
}

source-script() {
  local url="$1"
  local import="$(mktemp)"

  # ─< if $1 is a local file, source this one instead >─────────────────────────────────────
  if [ -f "$url" ]; then
    source "$url"
    sleep 0.1
    return 0
  else
    # ─< if $1 is a url, grab it and source it, also deletes afterwards >─────────────────────
    if command-exists curl; then
      curl -fsSL $url -o $import
    elif command-exists wget; then
      wget -o $import $url
    else
      echo "curl/wget is required, but missing.."
      exit 69
    fi

    source "$import"

    echo "${BLUE}Sourcing external script:${NC} $url"
    sleep 0.1
    rm -f "$import"
  fi
}

check-powerstation() {
  local hn="$(hostname)"
  write-config() {
    _conf() {
      cat <<EOF
$main = DP-1
$secondary = HDMI-A-1

monitor = $main, 3440x1440@165, 0x0, 1
monitor = $secondary, 2560x1440@95, 1600x-1440, 1
EOF
    }

    _conf >"$HOME/.monitors.conf"
  }

  if [ "$hn" == 'cl-powerstation' ]; then
    if [ -e "$HOME/.monitors.conf" ]; then
      if ! grep -qi '3440x1440@165' <<<"$(cat $HOME/.monitors.conf)"; then
        write-config
      fi
    else
      write-config
    fi
  else
    return 69
  fi
}

get-dependencies() {
  depends=(
    stow
    git
    bash
    curl
    unzip
    entr
  )

  check-and-install ${depends[@]}
}

askThings() {
  if [ ! -d ./dotfiles/.config/tmux/ ] && [ ! -d ./dotfiles/.config/zellij/ ]; then
    choose plexer "Choose a multiplexer" tmux zellij none </dev/tty
  fi
  [ "$plexer" == "none" ] && plexer=""

  if [ ! -d ./dotfiles/.config/rofi/ ] && [ ! -d ./dotfiles/.config/fuzzel/ ] && [ ! -d ./dotfiles/.config/tofi/ ]; then
    choose menu "Choose a menu" rofi tofi fuzzel none </dev/tty
  fi
  [ "$menu" == "none" ] && menu=""

  if [ ! -d ./dotfiles/.config/yazi/ ] && [ ! -d ./dotfiles/.config/lf/ ] && [ ! -d ./dotfiles/.config/ranger/ ]; then
    choose filemgr "Choose a cli filemanager" yazi ranger lf none </dev/tty
  fi
  [ "$filemgr" == "none" ] && filemgr=""

  if [ ! -d ./dotfiles/.config/waybar/ ] && [ ! -d ./dotfiles/.config/gBar/ ] && [ ! -d ./dotfiles/.config/hyprpanel/ ]; then
    if $arch; then
      choose bar "Choose a bar provider" waybar gbar hyprpanel quickshell none </dev/tty
    else
      choose bar "Choose a bar provider" waybar gbar none </dev/tty
    fi
  fi
  [ "$bar" == "none" ] && bar=""

  if [ ! -d ./dotfiles/.config/foot/ ] && [ ! -d ./dotfiles/.config/ghostty/ ] && [ ! -d ./dotfiles/.config/alacritty/ ] && [ ! -d ./dotfiles/.config/kitty/ ]; then
    choose terminal "Choose a Terminal config" alacritty foot ghostty kitty none </dev/tty
  fi
  [ "$terminal" == "none" ] && terminal="kitty"

  __optional__=false
  if confirm "Do you also want to install optional packages?" </dev/tty; then
    __optional__=true
  fi

  if ! command-exists nvim; then
    if confirm "Do you also want to install neovim" </dev/tty; then
      neovim=true

      if confirm "Do you also want to install a neovide config?" </dev/tty; then
        neovide=true
      fi
    else
      neovim=false
    fi
  fi
}

instPika() {
  if command-exists curl; then
    curl -fsSL "https://git.k4li.de/scripts/installs/raw/branch/main/${1}.sh" | bash
  else
    pen bold yellow "curl was not found, could not install $1!"
  fi
}

cloneDots() {
  choise="$1"
  cloneName="${2:-$1}"

  if command-exists git; then
    if [ -d ./dotfiles ] && [ ! -d "./dotfiles/${choise}" ]; then
      pen red bold "Depending on your internet speed, this might take a while.."
      spin yellow bold "Cloning dotfiles $cloneName"
      run git clone --depth=1 "https://git.k4li.de/dotfiles/${choise}.git" "./dotfiles/.config/${cloneName}" && check "Cloned dotfiles" || throw "Failed cloning dotfiles!"
    else
      throw "$choise is already cloned.."
    fi
  else
    throw "Git was not found"
  fi
}

__validate__() {
  if askThings; then
    [[ -n "$plexer" ]] && cloneDots "$plexer"
    [[ -n "$menu" ]] && cloneDots "$menu"
    [[ -n "$filemgr" ]] && cloneDots "$filemgr"
    [[ -n "$bar" ]] && cloneDots "$bar"
    [[ -n "$terminal" ]] && cloneDots "$terminal"

  else
    echo-error "Something went terribly wrong"
    exit 69
  fi
}

__dep__() {
  _depss=(
    "$terminal"
    "$bar"
    "$menu"
    "$filemgr"
    "$plexer"
    "hyprland"
    "btop"
    "zip"
    "fzf"
    "copyq"
    "rsync"
    "wlogout"
    "zoxide"
  )

  for hyprdots_dependency in "${_depss[@]}"; do
    case "$hyprdots_dependency" in
    zellij)
      instPika zellij
      ;;
    yazi)
      instPika yazi
      ;;
    hyprland)
      instPika hyprland
      ;;
    hyprpanel)
      instPika hyprpanel
      ;;
    neovim)
      if $neovim; then
        instPika neovim
        if confirm "Do you also want to install a neovide config?" </dev/tty; then
          instPika neovide
        fi
      fi
      ;;
    *)
      spin bold yellow "Installing $hyprdots_dependency.."
      if ! command-exists "$hyprdots_dependency"; then
        if run --err err pkg-install "$hyprdots_dependency"; then
          upclear
          check "$hyprdots_dependency installed"
        else
          upclear
          throw bold yellow "$hyprdots_dependency could not get installed"
          echo-error "${err:-}"
        fi
      else
        upclear
        check bold green "$hyprdots_dependency - $(pen yellow bold already installed)"
      fi
      ;;
    esac
  done
}

__monitors__() {
  if ! check-powerstation; then
    if [ ! -e "$HOME/.monitors.conf" ]; then
      res="$(hyprctl monitors | grep -oP '\d+x\d+@\d+\.\d+' | head -n 1)"
      touch "$HOME/.monitors.conf"
      if [[ -n $res ]]; then
        echo "monitor = eDP-1, ${res}, 0x0, 1" >>"$HOME/.monitors.conf"
      else
        echo "monitor = preferred,, 0x0, 1" >>"$HOME/.monitors.conf"
      fi
    fi
  else
    return 69
  fi
}

pkg_optional() {
  _ops=(
    "cowsay"
    "cmatrix"
    "trash-cli"
    "duf"
  )

  for pkg in "${_opts[@]}"; do
    spin "Installing $pkg"
    if ! command-exists $pkg; then
      run pkg-install $pkg && check "$pkg installed" || throw "Error installing $pkg"
    fi
  done
}

dots=()
homedots=()
get-stow-folders() {
  # find foldernames for all used and cloned configs
  if [ -d "./dotfiles" ]; then
    for i in "./dotfiles/.config/"*; do
      echo "DOTS: ${i#./dotfiles/.config/}"
      dots+=("${i#./dotfiles/.config/}")
    done
  fi

  # find .files for ./zsh/ and ./bash/ folders
  for d in zsh bash; do
    for i in "./$d/".*; do
      echo "HOMEDOTS: ${i#./$d/}"
      homedots+=("${i#./$d/}")
    done
  done
}

# move the .files and .config/folders to the $bak dir, as stow would try to
# migrate these, which will cause problems!
move-and-prestow() {
  local home_conf bak target moved=() dirs=()
  shopt -s nullglob

  home_conf=$HOME/.config
  bak=$HOME/.bak

  dirs=(
    "$bak"
    "$HOME/.config"
    "$HOME/.local/share/icons"
  )

  # create $bak dir if not present
  for d in "${dirs[@]}"; do
    if [ ! -d "$d" ]; then
      silent mkdir -p $bak
    fi
  done

  # move .config/folders to the $bak dir
  for i in "${dots[@]}"; do
    target=${home_conf}/$i
    if [ -d "$target" ]; then
      mv -f "$target" "$bak" && moved+=("$target")
    fi
  done

  # move $HOME/.files to the $bak dir
  for i in "${homedots[@]}"; do
    target=$HOME/$i
    if [[ -d "$target" || -e "$target" ]]; then
      mv -f "$target" "$bak" && moved+=("$target")
    fi
  done

  # printing the operations/debug
  echo "Moved ${#moved[@]} targets:"

  # printing exactly what files/folders were moved
  for m in "${moved[@]}"; do
    echo "${m} -> $bak"
  done
}

__stow__() {
  local err out
  spin grey bold "Linking dotfiles.."

  if run --err err stow --verbose --target="$HOME" --defer=.gitmodules --restow */; then
    upclear
    check "Linked dotfiles!"
  else
    upclear
    throw bold red "Could not use stow to link dofiles.."
    pen bold yellow "OUT: ${out:-}"
    echo-error "${err:-}"
  fi
}

c_fonts() {
  local err out
  local dirFonts="$HOME/.local/share/fonts/"
  local fontsRepo="https://git.k4li.de/pika/fonts.git"
  if [[ ! -d "$dirFonts" ]]; then
    if confirm "Seems like you may miss some fonts.. Do you want to clone them now into $(pen blue bold $dirFonts)" </dev/tty; then
      if ! command-exists git; then
        spin "Installing dependencies.."
        if run --err err --out out pkg-install git; then
          upclear
          check "Installed git!"
        else
          upclear
          throw "Couldn't install git!"
          pen bold yellow "OUT: ${out:-}"
          echo-error "${err:-}"
        fi
      else
        spin bold yellow "Cloning fonts from $fontsRepo"

        if run --err err --out out git clone --depth=1 "$fontsRepo" "$dirFonts"; then
          upclear
          check "Cloned fonts correctly!"
        else
          upclear
          throw "Error cloning fonts!"
          pen bold yellow "OUT: ${out:-}"
          echo-error "${err:-}"
        fi
      fi
    fi
  else
    pen bold yellow "Fonts are already present at $dirFonts"
  fi
}

c_wallpapers() {
  local wall_dir="$HOME/.wallpaper"
  if [[ ! -d "$wall_dir" ]]; then
    if confirm "Seems like you may miss some wallpaper.. Do you want to clone them now to $(pen blue bold "$wall_dir")?" </dev/tty; then
      spin blue bold "Cloning wallpaper repo.. This might take a while.."
      run --err err git clone --depth=1 https://git.k4li.de/pika/wallpaper.git "$wall_dir" && check bold green "Wallpapers cloned correctly!" || throw "Error downloading wallpapers!" && echo-error "${err:-}"
    else
      pen bold red "All right, be sure to checkout the $HOME/.config/hypr/scripts/wallpaper to change the wallpaper dir"
      return 0
    fi
  fi
}

make-dirs() {
  # ─< .config dir >────────────────────────────────────────────────────────────────────────
  local dirs=()
  dirs=(
    "$HOME/.config"
    "$HOME/.local/share/icons"
    "$HOME/.bak"
  )

  for d in "${dirs[@]}"; do
    if [[ ! -d "$d" ]]; then
      pen grey "mkdir $d"
      silentexec mkdir "$d"
    fi
  done

  c_fonts
  c_wallpapers
}

setup-env() {
  local dream=https://git.k4li.de/scripts/imports/raw/branch/main/dream.sh

  if ! command-exists pkg-install && ! command_exists check-and-install && ! command_exists spin; then
    source-script $dream
  fi
}

main() {
  __validate__
  __dep__

  make-dirs

  get-stow-folders
  move-and-prestow
  __stow__

  sleep 2

  if $__optional__; then
    pkg_optional
  fi

  __monitors__ &&
    pen blue bold "found resolution ${res}"
}

if setup-env; then
  main
fi