#!/bin/bash

if [ ! -f VERSION ]; then
  echo "ERROR: must be executed from top directory"
  exit 1
fi

version=`cat VERSION`
pdf_build_dir=build.pdf
macos_builddir=build.bundle-gcc
PUBLIC="plweb@oehoe:srv/plweb/data/download/devel"
export MACOSX_DEPLOYMENT_TARGET=10.15

build_pdf()
{ rm -rf build.pdf
  mkdir build.pdf
  ( cd build.pdf
    cmake -DBUILD_PDF_DOCUMENTATION=ON -G Ninja ..
    ninja
  )
}

# Build the Windows version using the Docker from
# https://github.com/SWI-Prolog/docker-swipl-build-mingw.git

MINGW_DOCKER_DIR=$HOME/src/docker/docker-swipl-build-mingw

build_win64()
{ make -C $MINGW_DOCKER_DIR SWIPLSRC=`pwd` win64
}

build_macos_universal_binary()
{ buildir=${1-build.macosx-fat}
  rm -rf $buildir
  mkdir $buildir
  ( cd $buildir
    PREFIX=$HOME/deps
    export PKG_CONFIG_LIBDIR="/usr/lib/pkgconfig:$PREFIX/lib/pkgconfig"
    export CMAKE_PREFIX_PATH="$PREFIX:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr"
    CUFLAGS="-arch x86_64"
    export CFLAGS="-Wno-nullability-completeness $CUFLAGS"
    export CXXFLAGS="$CFLAGS"
    export PATH=$HOME/deps/bin:$PATH
    MACOSX_DEPLOYMENT_TARGET=$MACOSX_DEPLOYMENT_TARGET \
	cmake -DCMAKE_BUILD_TYPE=Release \
	      -DSWIPL_CC=cc -DSWIPL_CXX=c++ \
	      -DMACOSX_DEPENDENCIES_FROM=$HOME/deps \
	      -DPKG_CONFIG_EXECUTABLE=/opt/local/bin/pkg-config \
              -DMACOS_UNIVERSAL_BINARY=ON \
              -DBUILD_MACOS_BUNDLE=ON \
	      -DJAVA_COMPATIBILITY=ON \
	      -DCMAKE_FRAMEWORK_PATH=/Library/Frameworks \
	      -G Ninja ..
    ninja
    cpack
  )
}

build_macos_gcc_arch()
{ arch=$1
  builddir=$2

  case $arch in
      arm64)
	  GCCDIR=/opt/local/bin
	  ;;
      x86_64)
	  GCCDIR=$HOME/x86_64/bin
	  ;;
      *)
	  echo "ERROR: Unknown architecture $arch"
	  return 1
  esac

  if [ -z "$builddir" ]; then
      echo "ERROR: Usage: $0 arch builddir"
      return 1
  fi

  rm -rf $builddir
  mkdir $builddir
  ( cd $builddir
    PREFIX=$HOME/deps
    export PKG_CONFIG_LIBDIR="/usr/lib/pkgconfig:$PREFIX/lib/pkgconfig"
    export CMAKE_PREFIX_PATH="$PREFIX:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr"
    export PATH=$HOME/deps/bin:$GCCDIR:$PATH
    export CC=gcc-mp-15
    export CXX=g++-mp-15
    MACOSX_DEPLOYMENT_TARGET=$MACOSX_DEPLOYMENT_TARGET \
	cmake -DCMAKE_BUILD_TYPE=PGO \
	      -DSWIPL_CC=cc -DSWIPL_CXX=c++ \
	      -DMACOSX_DEPENDENCIES_FROM=$HOME/deps \
	      -DPKG_CONFIG_EXECUTABLE=/opt/local/bin/pkg-config \
              -DMACOS_UNIVERSAL_BINARY=ON \
              -DBUILD_MACOS_BUNDLE=ON \
	      -DJAVA_COMPATIBILITY=ON \
	      -DCMAKE_FRAMEWORK_PATH=/Library/Frameworks \
	      -G Ninja ..
    ninja
  )
}

build_macos_gcc_universal()
{ buildir=${1-build.fat-gcc}
  buildir_x86_64=$buildir-x86_64
  build_macos_gcc_arch x86_64 $buildir_x86_64 || return 1
  build_macos_gcc_arch arm64 $buildir || return 1
  ( cd $buildir
    ../scripts/macos-import-x86_64.sh ../$buildir_x86_64 || return 1
    cpack
  )
}

build_macos_gcc()
{ buildir=${1-build.macosx-gcc}

  rm -rf $builddir
  mkdir $builddir
  ( cd $builddir
    PREFIX=$HOME/deps
    export PKG_CONFIG_LIBDIR="/usr/lib/pkgconfig:$PREFIX/lib/pkgconfig"
    export CMAKE_PREFIX_PATH="$PREFIX:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr"
    export CFLAGS="-Wno-nullability-completeness $CUFLAGS"
    export CXXFLAGS="$CFLAGS"
    export PATH=$HOME/deps/bin:$PATH
    export CC=gcc-mp-15
    export CXX=g++-mp-15
    MACOSX_DEPLOYMENT_TARGET=$MACOSX_DEPLOYMENT_TARGET \
	cmake -DCMAKE_BUILD_TYPE=PGO \
	      -DSWIPL_CC=cc -DSWIPL_CXX=c++ \
	      -DMACOSX_DEPENDENCIES_FROM=$HOME/deps \
	      -DPKG_CONFIG_EXECUTABLE=/opt/local/bin/pkg-config \
              -DBUILD_MACOS_BUNDLE=ON \
	      -DJAVA_COMPATIBILITY=ON \
	      -DCMAKE_FRAMEWORK_PATH=/Library/Frameworks \
	      -G Ninja ..
    ninja
    cpack
  )
}

build_source()
{ ./scripts/make-src-tape
}

ubuntu()
{ $HOME/src/docker/ubuntu/run.sh -C $(pwd) $*
}

reset_nox()
{ git -C debian checkout nox
  git -C debian reset --hard origin/nox-devel
  git submodule update debian
}

# Build a single PPA in case something went wrong and we need
# to retry.
build_PPA()
{ distro=$1

  git checkout ppa
  git rebase master
  ubuntu ./scripts/make-ppa --distro=$distro --push
  git checkout master
  git submodule update debian
}

# Build all PPAs
build_PPAs()
{ reset_nox
  git branch -D ppa || true
  git checkout -b ppa
  for distro in $(./scripts/make-ppa --list-distros); do
    ubuntu ./scripts/make-ppa --distro=$distro --push
  done
  git checkout master
  git submodule update debian
}

is_clean_release()
{ if [ V${version} != $(git describe) ]; then
    echo "ERROR: Git tag is inconsistent with release"
    return 1
  fi
  if [ ! -z "$(git diff -q)" ]; then
    echo "ERROR: Working directory is dirty"
    return 1
  fi
}

list_file()
{ if [ -f "$1" ]; then
     ls -l "$1"
  fi
}

list_built()
{ if [ $(uname) = Darwin ]; then
    list_file $macos_builddir/swipl-${version}-1.fat.dmg
  else
    ls -l build.win64/swipl-${version}-1.x64.exe
    ls -l build.pdf/man/SWI-Prolog-$version.pdf
    ls -l ../swipl-$version.tar.gz
  fi
}

build()
{ is_clean_release && force_build
}

force_build()
{ if [ $(uname) = Darwin ]; then
    if uname -a | grep arm64 > /dev/null; then
      build_macos_gcc_universal $macos_builddir
    else
      build_macos_gcc $macos_builddir
    fi
  else
    build_pdf
    build_win64
    build_source
    [ "$PPA" = no ] || build_PPAs
  fi

  list_built
}

################
# Uploading

upload_file()
{ if [ -f "$2" ]; then
    rsync -Pvu "$2" ${PUBLIC}/$1
  fi
}

upload_win64()
{ upload_file bin build.win64/swipl-${version}-1.x64.exe
}

upload_macosx()
{ if [ -f $macos_builddir/swipl-${version}-1.fat.dmg ]; then
    echo "Uploading MacOS binary version"
    upload_file bin $macos_builddir/swipl-${version}-1.fat.dmg
  fi
}

upload_pdf()
{ upload_file doc build.pdf/man/SWI-Prolog-$version.pdf
}

upload_src()
{ upload_file src ../swipl-$version.tar.gz
}

upload()
{ if [ $(uname) = Darwin ]; then
    upload_macosx
  else
    upload_win64
    upload_pdf
    upload_src
  fi
}
