#!/bin/sh


fname=$(basename "$0")
usage()
{
  echo "$fname <operation>"'

Operations:
  make <type>           : create Makefile
  main                  : create main source file
  ls                    : list source names
  src <type> <name...>  : create source files
  rm <name...>          : delete source files
  mv <name> <new>       : rename source files
  clear                 : delete all sources, headers, and binaries
  import <path> [name]  : import source files from another destination
  export <name> <path>  : export source files to another destination
  rclean [path]         : perform a recursive '"'make clean ; make clear'"'

Operation "src" can be abbrieviated to "s"'
}

if [ -n "$XDG_CONFIG_HOME" ]
then
  local_configpath="$XDG_CONFIG_HOME/zcsf"
else
  local_configpath="$HOME/.config/zcsf"
fi

usr_configpath="/usr/share/zcsf"

if [ -n "$CONFIGPATH" ]
then
  local_configpath="$CONFIGPATH"
fi

header_ifndef()
{
  echo "#ifndef $(echo "$1"_H"$2" | tr '[:lower:]' '[:upper:]')"
}
header_define()
{
  echo "#define $(echo "$1"_H"$2" | tr '[:lower:]' '[:upper:]')"
}
header_endif()
{
  echo "#endif //$(echo "$1"_H"$2" | tr '[:lower:]' '[:upper:]')"
}

clear_env()
{
  unset SRCDIR
  unset BINDIR
  unset IDIR
  unset ODIR
}

load_env()
{
  if [ ! -d "$1" ] ; then
    return
  fi
  if [ -f "$1/Makefile" ] ; then
    MAKEFILE="$1/Makefile"
  elif [ -f "$1/makefile" ] ; then
    MAKEFILE="$1/makefile"
  fi

  if [ -f "$MAKEFILE" ]
  then
    SRCDIR_T=$(grep "SRCDIR=" "$MAKEFILE" | cut -d'=' -f2- | head -n1)
    BINDIR_T=$(grep "BINDIR=" "$MAKEFILE" | cut -d'=' -f2- | head -n1)
    IDIR_T=$(grep "IDIR=" "$MAKEFILE" | cut -d'=' -f2- | head -n1)
    ODIR_T=$(grep "ODIR=" "$MAKEFILE" | cut -d'=' -f2- | head -n1)
    CC=$(grep "CC=" "$MAKEFILE" | cut -d'=' -f2- | head -n1)
  fi

  if [ "$CC" = "g++" ] || [ "$CPP" = "true" ]
  then
    PP="pp"
  fi

  # overwrite
  if [ -z "$SRCDIR" ] ; then SRCDIR=$SRCDIR_T ; fi
  if [ -z "$BINDIR" ] ; then BINDIR=$BINDIR_T ; fi
  if [ -z "$IDIR" ] ; then IDIR=$IDIR_T ; fi
  if [ -z "$ODIR" ] ; then ODIR=$ODIR_T ; fi

  # if empty
  if [ -z "$SRCDIR" ] ; then SRCDIR=. ; fi
  if [ -z "$BINDIR" ] ; then BINDIR=. ; fi
  if [ -z "$IDIR" ] ; then IDIR=. ; fi
  if [ -z "$ODIR" ] ; then ODIR=. ; fi

  unset SRCDIR_T
  unset BINDIR_T
  unset IDIR_T
  unset ODIR_T
  unset MAKEFILE
}

gen_chfiles()
{
  CFILE="$1.c$2"
  HFILE="$1.h$2"
  if [ ! -f "$CFILE" ]
  then
    echo "#include \"$HFILE\"" > "$SRCDIR/$CFILE"
  fi
  gen_hfile "$1" "$2"
}

gen_cfile()
{
  CFILE="$1.c$2"
  if [ ! -f "$1" ]
  then
    touch "$SRCDIR/$CFILE"
  fi
}

gen_hfile()
{
  HFILE="$1.h$2"
  if [ ! -f "$HFILE" ]
  then
    { header_ifndef "$1" "$2" ; header_define "$1" "$2" ; printf "\n\n\n" ; header_endif "$1" "$2" ;} > "$IDIR/$HFILE"
  fi
}

clean_all()
{
  if [ -z "$1" ] ; then
    spath=.
  else
    spath="$1"
  fi
  find "$spath" -name '[mM]akefile' -execdir sh -c 'make clean 2>/dev/null ; make clear 2>/dev/null' ';' 2>/dev/null
}

dir_gen()
{

    if [ ! -d "$SRCDIR" ]
    then
      mkdir -p "$SRCDIR"
    fi
    if [ ! -d "$BINDIR" ]
    then
      mkdir -p "$BINDIR"
    fi
    if [ ! -d "$IDIR" ]
    then
      mkdir -p "$IDIR"
    fi
    if [ ! -d "$ODIR" ]
    then
      mkdir -p "$ODIR"
    fi
}

gen_make()
{
  if [ -f "$local_configpath/Makefile$1" ] ; then
    mpath="$local_configpath/Makefile$1"
  else
    mpath="$usr_configpath/Makefile$1"
  fi
  cp "$mpath" Makefile 2>/dev/null || touch Makefile
}

gen_main()
{
  if [ -f "$local_configpath/main.c$1" ] ; then
    mpath="$local_configpath/main.c$1"
  else
    mpath="$usr_configpath/main.c$1"
  fi
  cp "$mpath" "$SRCDIR" 2>/dev/null || touch "$SRCDIR/main.c$1"
}

# $1 = filename , $2 = new name
smart_mv()
{
  if [ -f "$SRCDIR/$1.c" ] ; then
    CFILE="$1.c"
    CFILE2="$2.c"
  elif [ -f "$SRCDIR/$1.cpp" ] ; then
    CFILE="$1.cpp"
    CFILE2="$2.cpp"
  fi
  if [ -f "$IDIR/$1.h" ] ; then
    HFILE="$1.h"
    HFILE2="$2.h"
  elif [ -f "$IDIR/$1.hpp" ] ; then
    HFILE="$1.hpp"
    HFILE2="$2.hpp"
  fi

  [ -z "$CFILE" ] && [ -z "$HFILE" ] && echo "'$1' not found" >&2 && return 1

  [ -n "$CFILE" ] && mv "$SRCDIR/$CFILE" "$SRCDIR/$CFILE2"

  if [ -n "$HFILE" ]
  then
    mv "$IDIR/$HFILE" "$IDIR/$HFILE2" || return $?
    find "$SRCDIR" "$IDIR" -type f -regex '.*\.[ch]p?p?$' -exec sed -i "s:#include \"$HFILE\":#include \"$HFILE2\":g" "{}" "+"
    sed -i "s:$(header_ifndef "$1"):$(header_ifndef "$2"):g;s:$(header_define "$1"):$(header_define "$2"):g;s:$(header_endif "$1"):$(header_endif "$2"):g" "$IDIR/$HFILE2"
  fi

}

list_c()
{
  (
  cd "$SRCDIR" || exit
  if [ -f "main.c" ] || [ -f "main.cpp" ] ; then echo "main" ; fi
  find . -type f -regex '.*\.cp?p?$' | cut -d '/' -f2- | sed 's/\.cpp$//g;s/\.c$//g;/main/d'
  )
}
list_h()
{
  (
  cd "$IDIR" || exit
  find . -type f -regex '.*\.hp?p?$' | cut -d '/' -f2- | sed 's/\.hpp$//g;s/\.h$//g;/^$/d'
  )
}

load_env .

case $1 in

  main) dir_gen && gen_main $PP ;;
  ls)  { list_c && list_h; } | sort | uniq ;;
  mv) smart_mv "$2" "$3"  ;;
  rclean) clean_all "$2" ;;

  make)
    unset help
    case $2 in
      c)        gen_make "" ;;
      cpp|c++)  gen_make "_cpp" ;;
      *)        echo "$fname make <type>
Types:
  c         : C automatic makefile
  cpp/c++   : C++ automatic makefile"
    esac
  ;;

  clear)
    make clean >/dev/null 2>&1 ;  make clear >/dev/null 2>&1
    # bin
    [ "$BINDIR" != "." ] && rm -rd "$BINDIR" 2> /dev/null
    # src
    if [ "$SRCDIR" != "." ]
    then rm -rd "$SRCDIR" 2> /dev/null
    else rm ./*.c ./*.cpp 2> /dev/null
    fi
    # include
    if [ "$IDIR" != "." ]
    then rm -rd "$IDIR" 2> /dev/null
    else rm ./*.h ./*.hpp 2> /dev/null
    fi
    # obj
    [ "$ODIR" != "." ] && rm -rd "$ODIR" 2> /dev/null
  ;;

  src|s)
    case $2 in
      a|auto)   f=y && pp=$PP ;;
      f)        f=y           ;;
      fpp|c++)  f=y && pp=pp  ;;
      c)        c=y           ;;
      cpp|c++)  c=y && pp=pp  ;;
      h)        h=y           ;;
      hpp|h++)  h=y && pp=pp  ;;
      *)
        echo "$fname src <type> <names>
Types:
  a/auto    : create .c[pp] and .h[pp] files correspondingly
  f         : create .c and .h files
  fpp/f++   : create .cpp and .hpp files
  c         : create .c file
  cpp/c++   : create .cpp file
  h         : create .h file
  hpp       : create .hpp file"
        exit 1
    esac
    dir_gen
    shift $((OPTIND+1))
    for N
    do
      [ -n "$c" ] && gen_cfile "$N" "$pp"
      [ -n "$h" ] && gen_hfile "$N" "$pp"
      [ -n "$f" ] && gen_chfiles "$N" "$pp"
    done
  ;;

  rm)
    shift $((OPTIND))
    for N
    do
      rm "$SRCDIR/$N.c" "$SRCDIR/$N.cpp" "$IDIR/$N.h" "$IDIR/$N.hpp" 2>/dev/null
    done
  ;;

  import)
    SRCDIR_S=$SRCDIR
    IDIR_S=$IDIR

    clear_env

    import_path="$2"
    if [ ! -d "$import_path" ] ; then
      echo "Cannot find '$import_path'"
      exit 1
    fi
    load_env "$import_path"

    if [ -n "$3" ]
    then
      if [ -f "$import_path/$SRCDIR/$3.c" ] ; then
        cp "$import_path/$SRCDIR/$3.c" "$SRCDIR_S"
        _OK=y
      fi
      if [ -f "$import_path/$SRCDIR/$3.cpp" ] ; then
        cp "$import_path/$SRCDIR/$3.cpp" "$SRCDIR_S"
        _OK=y
      fi
      if [ -f "$import_path/$IDIR/$3.h" ] ; then
        cp "$import_path/$IDIR/$3.h" "$IDIR_S"
        _OK=y
      fi
      if [ -f "$import_path/$IDIR/$3.hpp" ] ; then
        cp "$import_path/$IDIR/$3.hpp" "$IDIR_S"
        _OK=y
      fi
      if [ -z "$_OK" ]
      then
        echo "Cannot find '$3' at '$import_path'" >&2
        exit 1
      fi
    else
      find "$import_path/$SRCDIR" -regex '.*\.cp?p?$' -exec cp "{}" "$SRCDIR_S/" ";"
      find "$import_path/$IDIR" -regex '.*\.hp?p?$' -exec cp "{}" "$IDIR_S/" ";"
    fi
  ;;

  export)
    if [ -f "$SRCDIR/$2.c" ] ; then
      CFILE="$2.c"
      CFILE2="$3.c"
    elif [ -f "$SRCDIR/$2.cpp" ] ; then
      CFILE="$2.cpp"
      CFILE2="$3.cpp"
    fi
    if [ -f "$IDIR/$2.h" ] ; then
      HFILE="$2.h"
      HFILE2="$3.h"
    elif [ -f "$IDIR/$2.hpp" ] ; then
      HFILE="$2.hpp"
      HFILE2="$3.hpp"
    fi

    clear_env

    export_path="$3"
    if [ ! -d "$export_path" ] ; then
      echo "Cannot find '$import_path'" >&2
      exit 1
    fi
    load_env "$export_path"

    cp "$SRCDIR_S/$CFILE" "$export_path/$SRCDIR"
    cp "$IDIR_S/$HFILE" "$export_path/$IDIR"
  ;;

  *) usage ; exit 1 ;;
esac