#!/bin/bash
# Copyright (C) 2016 Ian Kelling
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


[[ $EUID == 0 ]] || exec sudo -E "${BASH_SOURCE[0]}" "$@"

source /usr/local/lib/err

shopt -s nullglob

usage() {
  cat <<EOF
usage: $0 SUBVOL_MOUNTPOINT... | -p SUBVOL_PATH...

In git this is not not executable because it's meant to be installed
using ./install-my-scripts

Print the unstale subvol name into /nocow/btrfs-stale/\$subvol

If latest subvols \$@ are not mounted, print a message to terminal.

Fresh is opposite of stale. To be fresh, either SUBVOL_MOUNTPOINT is a
snapshot of the latest, or the latest snapshot is snapshot of
SUBVOL_MOUNTPOINT.

-p            Args are SUBVOL_PATH, not mountpoints from which we derive
              that information.
-v|--verbose  Be more verbose
-h|--help  Print help and exit.

Note: Uses GNU getopt options parsing style
EOF
  exit $1
}

##### begin command line parsing ########

subvol_path=false
verbose=false
temp=$(getopt -l help,verbose hpv "$@") || usage 1
eval set -- "$temp"
while true; do
  case $1 in
    -p) subvol_path=true ;;
    -v|--verbose) verbose=true ;;
    -h|--help) usage ;;
    --) shift; break ;;
    *) echo "$0: unexpected args: $*" >&2 ; usage 1 ;;
  esac
  shift
done

if [[ ! $1 ]]; then
  echo "$0: error: expected mountpoint argument"
fi

stale-file() {
  stale_dir=/nocow/btrfs-stale
  stale_file=$stale_dir/$vol
  if $stale; then
    mkdir -p $stale_dir
    printf "%s\n" $freshest_snap > $stale_file
  else
    rm -f $stale_file
  fi

}
d() {
  if $verbose; then
    printf "%s\n" "$*"
  fi
}

# duplicated in mount-latest-sub
# Reassign $1 var from /dev/dm- to corresponding /dev/mapper/
mapper-dev() {
  local mapdev
  local -n devref=$1
  if [[ $devref == /dev/dm-* ]]; then
    for mapdev in /dev/mapper/*; do
      if [[ $(readlink -f $mapdev) == "$devref" ]]; then
        devref=$mapdev
        break
      fi
    done
  fi
}

for d; do
  if $subvol_path; then
    svp=$d
    root_dir=${d%/*}
    subvol_dir=${d##*/}
    vol=$subvol_dir
  else
    vol=${d##*/}
    # second field, non-comment line == $d
    dev=$(sed -rn "s,^\s*([^#]\S*)\s+$d\s.*,\1,p" /etc/fstab /etc/mtab|head -n1)

    d dev=$dev
    subvol_dir=$(sed -rn "s,^\s*[^#]\S*\s+$d\s.*\bsubvol=([a-zA-A/]+).*,\1,p" /etc/fstab /etc/mtab|head -n1)
    if [[ ! $subvol_dir ]]; then
      continue
    fi
    d subvol_dir=$subvol_dir

    ### begin getting root_dir
    ### this is duplicated in mount-latest-subvol
    # note, we need $dev because $d might not be mounted, and we do this loop
    # because the device in fstab for the rootfs can be different.
    for devx in $(btrfs fil show $dev| sed -rn 's#.*path (\S+)$#\1#p'); do
      if [[ $devx == dm-* ]]; then
        devx=/dev/$devx
        d mapper-dev $devx
        mapper-dev devx
      fi
      d devx=$devx
      root_dir=$(sed -rn "s,^\s*$devx\s+(\S+).*\bsubvolid=[05]\b.*,\1,p" /etc/mtab /etc/fstab|head -n1)
      if [[ $root_dir ]]; then
        d root_dir=$root_dir
        break
      fi
    done
    if [[ ! $root_dir ]]; then
      echo "$0: error could not find root subvol mount for $dev" >&2
      exit 1
    fi
    ### end getting root_dir
    svp=$root_dir/$subvol_dir # subvolume path
    d "svp=$svp # subvolume path"
  fi

  snaps=($root_dir/btrbk/$subvol_dir.20*) # Assumes we are in the 21st century.
  if [[ ! ${snaps[*]} ]]; then
    # no snapshots yet
    # TODO: make this an error and override with a cli flag
    echo "$0: warning: no snapshots found at $root_dir/btrbk/$subvol_dir.20*. this is expected for a brand new volume"
    continue
  fi

  # get info on last received sub
  last_received=
  last_received_cgen=0
  for f in ${snaps[@]}; do
    show="$(btrfs sub show $f)"
    if echo "$show" | grep -E "Received UUID:\s+[[:alnum:]]" &>/dev/null; then
      d found received uuid in $f
      cgen=$(echo "$show" | sed -rn 's,^\s*Gen at creation:\s+([0-9]+).*,\1,p')
      if [[ $cgen -gt $last_received_cgen ]]; then
        last_received_cgen=$cgen
        last_received=$f
      fi
    fi
  done
  d last_received_cgen=$last_received_cgen
  d last_received=$last_received

  # Get last_snap by date.
  # when a btrbk bugfix makes it into the distro,
  # we might replace this with btrbk list latest /mnt/root/$vol | ...
  last_snap=$(
    for s in ${snaps[@]}; do
      f=${s##*/}
      unix_time=$(date -d $(sed -r  's/(.{4})(..)(.{5})(..)(.*)/\1-\2-\3:\4:\5/' <<<${f#$vol.}) +%s)
      printf "%s %s\n" $unix_time $s # part of the pipeline
      # sort will fail
    done | sort -r | head -n 1 | awk '{print $2}' || [[ ${PIPESTATUS[1]} == 141 || ${PIPESTATUS[0]} == 32 ]]
           )
  if [[ ! $last_snap ]]; then
    # should not happen.
    echo "$0: error: could not find latest snapshot for $svp among ${snaps[*]}" >&2
    exit 1
  fi
  d last_snap=$last_snap

  if [[ ! -e $svp ]]; then
    echo "$0: warning: subvol does not exist: $svp"
    echo "$0 assuming this host was just for receiving and latest snap is freshest"
    freshest_snap=$last_snap
    stale=true
    stale-file
    continue
  fi


  # if there is a last_received, we can assume stale or fresh if we are newer/older
  if [[ $last_received ]]; then
    svp_cgen=$(btrfs sub show $svp | sed -rn 's,^\s*Gen at creation:\s+([0-9]+).*,\1,p')
    d svp_cgen=$svp_cgen
    if [[ $svp_cgen -ge $last_received_cgen ]]; then
      stale=false
    else
      d "$svp stale: it's gen at creation, $svp_cgen, is earlier than the last received snapshot, $last_received's gen at creation: $last_received_cgen"
      freshest_snap=$last_received
      stale=true
    fi
    stale-file
    continue
  fi

  # fallback to using last_snap as the freshest
  freshest_snap=$last_snap
  stale=true
  # fresh if $svp has $last_snap as a snapshot,
  if btrfs sub show $svp 2>/dev/null | sed '0,/^\s*Snapshot(s):/d;s/^\s*//' | \
      grep -xF ${last_snap#$root_dir/} ; then
    stale=false
  else # or else $svp is a snapshot of $last_snap. we use a uuid
    # comparison, which if I remember from the docs, is a bit more
    # robust, perhaps to renames.
    last_snap_uuid=$(btrfs sub show $last_snap| awk '$1 == "UUID:" {print $2}')
    if btrfs sub show $svp| grep "^\s*Parent UUID:\s*$last_snap_uuid$" &>/dev/null; then
      stale=false
    fi
  fi

  stale-file
done