# Copyright (c) 2020 Status Research & Development GmbH. Licensed under
# either of:
# - Apache License, version 2.0
# - MIT license
# at your option. This file may not be copied, modified, or distributed except
# according to those terms.

SHELL := bash # the shell used internally by Make

# used inside the included makefiles
BUILD_SYSTEM_DIR := vendor/nimbus-build-system

# Deactivate nimbus-build-system LINK_PCRE logic in favor of PCRE variables
# defined later in this Makefile.
export LINK_PCRE := 0

# we don't want an error here, so we can handle things later, in the ".DEFAULT" target
-include $(BUILD_SYSTEM_DIR)/makefiles/variables.mk

.PHONY: \
	all \
	chat \
	clean \
	clean-build-dirs \
	clean-migration-files \
	clean-sqlcipher \
	deps \
	migrations \
	nat-libs-sub \
	rlnlib-sub \
	sqlcipher \
	test \
	update \
	waku_chat2

ifeq ($(NIM_PARAMS),)
# "variables.mk" was not included, so we update the submodules.
GIT_SUBMODULE_UPDATE := git submodule update --init --recursive
.DEFAULT:
	+@ echo -e "Git submodules not found. Running '$(GIT_SUBMODULE_UPDATE)'.\n"; \
		$(GIT_SUBMODULE_UPDATE); \
		echo
# Now that the included *.mk files appeared, and are newer than this file, Make will restart itself:
# https://www.gnu.org/software/make/manual/make.html#Remaking-Makefiles
#
# After restarting, it will execute its original goal, so we don't have to start a child Make here
# with "$(MAKE) $(MAKECMDGOALS)". Isn't hidden control flow great?

else # "variables.mk" was included. Business as usual until the end of this file.

all: sqlcipher

# must be included after the default target
-include $(BUILD_SYSTEM_DIR)/makefiles/targets.mk

ifeq ($(OS),Windows_NT) # is Windows_NT on XP, 2000, 7, Vista, 10...
 detected_OS := Windows
else ifeq ($(strip $(shell uname)),Darwin)
 detected_OS := macOS
else
 # e.g. Linux
 detected_OS := $(strip $(shell uname))
endif

clean: | clean-common clean-build-dirs clean-migration-files clean-sqlcipher

clean-build-dirs:
	rm -rf \
		test/build

clean-migration-files:
	rm -f \
		nim_status/migrations/sql_scripts_accounts.nim \
		nim_status/migrations/sql_scripts_app.nim

clean-sqlcipher:
	cd vendor/nim-sqlcipher && $(MAKE) clean-build-dirs
	cd vendor/nim-sqlcipher && $(MAKE) clean-sqlcipher

LIBMINIUPNPC := $(shell pwd)/vendor/nim-waku/vendor/nim-nat-traversal/vendor/miniupnp/miniupnpc/libminiupnpc.a
LIBNATPMP := $(shell pwd)/vendor/nim-waku/vendor/nim-nat-traversal/vendor/libnatpmp-upstream/libnatpmp.a

# nat-libs target assumes libs are in vendor subdir of working directory;
# also, in msys2 environment miniupnpc's Makefile.mingw's invocation of
# `wingenminiupnpcstrings.exe` will fail if containing directory is not in PATH
$(LIBMINIUPNPC):
	cd vendor/nim-waku && \
		PATH="$$(pwd)/vendor/nim-nat-traversal/vendor/miniupnp/miniupnpc:$${PATH}" \
		$(ENV_SCRIPT) $(MAKE) USE_SYSTEM_NIM=1 nat-libs

$(LIBNATPMP): $(LIBMINIUPNPC)

nat-libs-sub: $(LIBMINIUPNPC) $(LIBNATPMP)

deps: | deps-common nat-libs-sub rlnlib-sub

update: | update-common

ifndef SHARED_LIB_EXT
 ifeq ($(detected_OS),macOS)
  SHARED_LIB_EXT := dylib
 else ifeq ($(detected_OS),Windows)
  SHARED_LIB_EXT := dll
 else
  SHARED_LIB_EXT := so
 endif
endif

# For release builds of e.g. `examples/chat.nim`, it would be good to support
# older versions of macOS (older relative to the machine that's used to build
# the executable); for that to work, linking must be done against builds of
# OpenSSL, PCRE, RLN, etc. that are properly built to support the same older
# version of macOS we desire to target. That means compiling them ourselves or
# downloading pre-built Homebrew bottles for that older version of macOS
# (keeping in mind the oldest version of macOS that Homebrew supports,
# currently 10.14), tweaking Rust compiler flags, etc. That logic should
# probably be triggered with respect to `RELEASE=true` and then setting up
# and/or overriding variables and running targets in this Makefile (via
# `$(MAKE) [target]`) to do steps that are unnecessary apart from release
# builds for macOS.
# MACOSX_DEPLOYMENT_TARGET ?= 10.14

RELEASE ?= false

ifneq ($(RELEASE),false)
 LOG_LEVEL ?= INFO
else
 LOG_LEVEL ?= DEBUG
endif
ifeq ($(LOG_LEVEL),)
 override LOG_LEVEL = DEBUG
endif

ifneq ($(RELEASE),false)
 RLN_CARGO_BUILD_FLAGS := --release
 RLN_TARGET_SUBDIR := release
 ifeq ($(detected_OS),Windows)
  WIN_STATIC := true
 else
  WIN_STATIC := false
 endif
else
 RLN_TARGET_SUBDIR := debug
 WIN_STATIC := false
endif
RLN_LIB_DIR := $(shell pwd)/vendor/nim-waku/vendor/rln/target/$(RLN_TARGET_SUBDIR)
RLN_STATIC ?= true
ifeq ($(RLN_STATIC),false)
 ifeq ($(detected_OS),Windows)
  RLN_LIB := $(RLN_LIB_DIR)/librln.$(SHARED_LIB_EXT).a
 else
  RLN_LIB := $(RLN_LIB_DIR)/librln.$(SHARED_LIB_EXT)
 endif
else
 RLN_LIB := $(RLN_LIB_DIR)/librln.a
endif

$(RLN_LIB):
	cd vendor/nim-waku && \
		cargo build \
			$(RLN_CARGO_BUILD_FLAGS) \
			--manifest-path vendor/rln/Cargo.toml

ifeq ($(detected_OS),macOS)
	install_name_tool -id \
		@rpath/librln.$(SHARED_LIB_EXT) \
		$(RLN_LIB_DIR)/librln.$(SHARED_LIB_EXT)
endif

rlnlib-sub: $(RLN_LIB)

MIGRATIONS ?= nim_status/migrations/sql_scripts_app.nim

$(MIGRATIONS): | deps
	$(ENV_SCRIPT) nim c $(NIM_PARAMS) --verbosity:0 nim_status/migrations/sql_generate.nim
	nim_status/migrations/sql_generate nim_status/migrations/accounts > nim_status/migrations/sql_scripts_accounts.nim
	nim_status/migrations/sql_generate nim_status/migrations/app > nim_status/migrations/sql_scripts_app.nim

migrations: clean-migration-files $(MIGRATIONS)

# These SSL variables and logic work like those in nim-sqlcipher's Makefile
ifeq ($(detected_OS),macOS)
 SSL_INCLUDE_DIR ?= /usr/local/opt/openssl/include
 ifeq ($(SSL_INCLUDE_DIR),)
  override SSL_INCLUDE_DIR = /usr/local/opt/openssl/include
 endif
 SSL_LIB_DIR ?= /usr/local/opt/openssl/lib
 ifeq ($(SSL_LIB_DIR),)
  override SSL_LIB_DIR = /usr/local/opt/openssl/lib
 endif
else ifeq ($(detected_OS),Windows)
 SSL_INCLUDE_DIR ?= /mingw64/include/openssl
 ifeq ($(SSL_INCLUDE_DIR),)
  override SSL_INCLUDE_DIR = /mingw64/include/openssl
 endif
 SSL_LIB_DIR ?= /mingw64/lib
 ifeq ($(SSL_LIB_DIR),)
  override SSL_LIB_DIR = /mingw64/lib
 endif
else
 SSL_INCLUDE_DIR ?= /usr/include
 ifeq ($(SSL_INCLUDE_DIR),)
  override SSL_INCLUDE_DIR = /usr/include
 endif
 SSL_LIB_DIR ?= /usr/lib/x86_64-linux-gnu
 ifeq ($(SSL_LIB_DIR),)
  override SSL_LIB_DIR = /usr/lib/x86_64-linux-gnu
 endif
endif
SSL_STATIC ?= true
ifndef SSL_LDFLAGS
 ifeq ($(SSL_STATIC),false)
  ifeq ($(detected_OS),Windows)
   SSL_LDFLAGS := -L$(shell cygpath -m $(SSL_LIB_DIR)) -lssl -lcrypto
  else
   SSL_LDFLAGS := -L$(SSL_LIB_DIR) -lssl -lcrypto
  endif
 else
  ifeq ($(detected_OS),Windows)
   SSL_LDFLAGS := $(shell cygpath -m $(SSL_LIB_DIR)/libssl.a) $(shell cygpath -m $(SSL_LIB_DIR)/libcrypto.a)
  else
   SSL_LDFLAGS := $(SSL_LIB_DIR)/libssl.a $(SSL_LIB_DIR)/libcrypto.a
  endif
 endif
 ifeq ($(detected_OS),Windows)
  SSL_LDFLAGS += -lws2_32
 endif
endif
NIM_PARAMS += --define:ssl
ifneq ($(SSL_STATIC),false)
 ifeq ($(detected_OS),Windows)
  NIM_PARAMS += --dynlibOverride:ssl- --dynlibOverride:crypto- --define:noOpenSSLHacks --define:sslVersion:"("
 else
  NIM_PARAMS += --dynlibOverride:ssl --dynlibOverride:crypto
 endif
endif

SQLCIPHER_STATIC ?= true
ifeq ($(SQLCIPHER_STATIC),false)
 SQLCIPHER ?= vendor/nim-sqlcipher/lib/libsqlcipher.$(SHARED_LIB_EXT)
else
 SQLCIPHER ?= vendor/nim-sqlcipher/lib/libsqlcipher.a
endif

$(SQLCIPHER): | deps
	echo -e $(BUILD_MSG) "$@"
	+ cd vendor/nim-sqlcipher && \
		$(ENV_SCRIPT) $(MAKE) \
			SQLCIPHER_STATIC=$(SQLCIPHER_STATIC) \
			SSL_INCLUDE_DIR="$(SSL_INCLUDE_DIR)" \
			SSL_LIB_DIR="$(SSL_LIB_DIR)" \
			SSL_STATIC=$(SSL_STATIC) \
			USE_SYSTEM_NIM=1 \
			sqlcipher

sqlcipher: $(SQLCIPHER)

ifeq ($(detected_OS),macOS)
 PCRE_INCLUDE_DIR ?= /usr/local/opt/pcre/include
 ifeq ($(PCRE_INCLUDE_DIR),)
  override PCRE_INCLUDE_DIR = /usr/local/opt/pcre/include
 endif
 PCRE_LIB_DIR ?= /usr/local/opt/pcre/lib
 ifeq ($(PCRE_LIB_DIR),)
  override PCRE_LIB_DIR = /usr/local/opt/pcre/lib
 endif
else ifeq ($(detected_OS),Windows)
 PCRE_INCLUDE_DIR ?= /mingw64/include
 ifeq ($(PCRE_INCLUDE_DIR),)
  override PCRE_INCLUDE_DIR = /mingw64/include
 endif
 PCRE_LIB_DIR ?= /mingw64/lib
 ifeq ($(PCRE_LIB_DIR),)
  override PCRE_LIB_DIR = /mingw64/lib
 endif
else
 PCRE_INCLUDE_DIR ?= /usr/include
 ifeq ($(PCRE_INCLUDE_DIR),)
  override PCRE_INCLUDE_DIR = /usr/include
 endif
 PCRE_LIB_DIR ?= /usr/lib/x86_64-linux-gnu
 ifeq ($(PCRE_LIB_DIR),)
  override PCRE_LIB_DIR = /usr/lib/x86_64-linux-gnu
 endif
endif
PCRE_STATIC ?= true
ifndef PCRE_LDFLAGS
 ifeq ($(PCRE_STATIC),false)
  ifeq ($(detected_OS),Windows)
   PCRE_LDFLAGS := -L$(shell cygpath -m $(PCRE_LIB_DIR)) -lpcre
  else
   PCRE_LDFLAGS := -L$(PCRE_LIB_DIR) -lpcre
  endif
 else
  ifeq ($(detected_OS),Windows)
   PCRE_LDFLAGS := $(shell cygpath -m $(PCRE_LIB_DIR)/libpcre.a)
  else
   PCRE_LDFLAGS := $(PCRE_LIB_DIR)/libpcre.a
  endif
 endif
endif
ifneq ($(PCRE_STATIC),false)
 NIM_PARAMS += --define:usePcreHeader --dynlibOverride:pcre
else ifeq ($(detected_OS),Windows)
 # to avoid Nim looking for pcre64.dll since we assume msys2 environment
 NIM_PARAMS += --define:usePcreHeader
endif

ifeq ($(detected_OS),macOS)
 NCURSES_LIB_DIR ?= /usr/local/opt/ncurses/lib
 ifeq ($(NCURSES_LIB_DIR),)
  override NCURSES_LIB_DIR = /usr/local/opt/ncurses/lib
 endif
else ifeq ($(detected_OS),Windows)
 NCURSES_LIB_DIR ?= /mingw64/lib
 ifeq ($(NCURSES_LIB_DIR),)
  override NCURSES_LIB_DIR = /mingw64/lib
 endif
else
 NCURSES_LIB_DIR ?= /usr/lib/x86_64-linux-gnu
 ifeq ($(NCURSES_LIB_DIR),)
  override NCURSES_LIB_DIR = /usr/lib/x86_64-linux-gnu
 endif
endif
NCURSES_STATIC ?= true
ifndef NCURSES_LDFLAGS
 ifeq ($(NCURSES_STATIC),false)
  ifeq ($(detected_OS),Windows)
   NCURSES_LDFLAGS := -L$(shell cygpath -m $(NCURSES_LIB_DIR)) -lncursesw
  else ifeq ($(detected_OS),macOS)
   NCURSES_LDFLAGS := -L$(NCURSES_LIB_DIR) -lncursesw -rpath $(NCURSES_LIB_DIR)
  else
   NCURSES_LDFLAGS := -L$(NCURSES_LIB_DIR) -lncursesw
  endif
 else
  ifeq ($(detected_OS),Windows)
   NCURSES_LDFLAGS := $(shell cygpath -m $(NCURSES_LIB_DIR)/libncursesw.a)
  else ifeq ($(detected_OS),macOS)
   NCURSES_LDFLAGS := $(NCURSES_LIB_DIR)/libncursesw.a
  else
   NCURSES_LDFLAGS := $(NCURSES_LIB_DIR)/libncursesw.a $(NCURSES_LIB_DIR)/libtinfo.a
  endif
 endif
endif
ifneq ($(PCRE_STATIC),false)
 NIM_PARAMS += --dynlibOverride:ncursesw
endif

ifndef RLN_LDFLAGS
 ifeq ($(RLN_STATIC),false)
  ifeq ($(detected_OS),macOS)
   RLN_LDFLAGS := -L$(RLN_LIB_DIR) -lrln -rpath $(RLN_LIB_DIR)
  else ifeq ($(detected_OS),Windows)
   ifneq ($(WIN_STATIC),false)
    RLN_LDFLAGS := -L$(shell cygpath -m $(RLN_LIB_DIR)) -lrln -luserenv
   else
    RLN_LDFLAGS := -L$(shell cygpath -m $(RLN_LIB_DIR)) -lrln
   endif
  else
   RLN_LDFLAGS := -L$(RLN_LIB_DIR) -lrln
  endif
 else
  ifeq ($(detected_OS),Windows)
   RLN_LDFLAGS := $(shell cygpath -m $(RLN_LIB)) -luserenv
  else ifeq ($(detected_OS),macOS)
   RLN_LDFLAGS := $(RLN_LIB)
  else
   RLN_LDFLAGS := $(RLN_LIB) -lm
  endif
 endif
endif
# ifneq ($(RLN_STATIC),false)
# usually `--dynlibOverride` is used in case of static linking and so would be
# used conditionally (see commented `ifneq` above), but because
# `vendor/nim-waku/waku/v2/protocol/waku_rln_relay/rln.nim` specifies the
# library with a relative path prefix (which isn't valid relative to root of
# this repo) it needs to be used in the case of shared or static linking
ifeq ($(detected_OS),Windows)
 NIM_PARAMS += --dynlibOverride:vendor\\rln\\target\\debug\\rln
else
 NIM_PARAMS += --dynlibOverride:vendor/rln/target/debug/librln
endif
# endif
NIM_PARAMS += --define:rln

ifeq ($(SQLCIPHER_STATIC),false)
 ifeq ($(detected_OS),Windows)
  SQLCIPHER_LDFLAGS := -L$(shell cygpath -m $(shell pwd)/$(shell dirname $(SQLCIPHER))) -lsqlcipher
 else
  SQLCIPHER_LDFLAGS := -L$(shell pwd)/$(shell dirname $(SQLCIPHER)) -lsqlcipher
 endif
else
 ifeq ($(detected_OS),Windows)
  SQLCIPHER_LDFLAGS := $(shell cygpath -m $(shell pwd)/$(SQLCIPHER))
 else
  SQLCIPHER_LDFLAGS := $(shell pwd)/$(SQLCIPHER)
 endif
endif

ifndef NIMSTATUS_CFLAGS
 ifneq ($(PCRE_STATIC),false)
  ifeq ($(detected_OS),Windows)
   NIMSTATUS_CFLAGS := -DPCRE_STATIC -I$(shell cygpath -m $(PCRE_INCLUDE_DIR))
  else
   NIMSTATUS_CFLAGS := -I$(PCRE_INCLUDE_DIR)
  endif
 endif
endif
ifneq ($(NIMSTATUS_CFLAGS),)
 NIM_PARAMS += --passC:"$(NIMSTATUS_CFLAGS)"
endif

# for NCURSES, PCRE, SSL assume linkable from default location, e.g. /usr/lib/x86_64-linux-gnu
LD_LIBRARY_PATH_NIMBLE := $${LD_LIBRARY_PATH}
ifeq ($(RLN_STATIC),false)
 LD_LIBRARY_PATH_NIMBLE := $(RLN_LIB_DIR):$(LD_LIBRARY_PATH_NIMBLE)
endif
ifeq ($(SQLCIPHER_STATIC),false)
 LD_LIBRARY_PATH_NIMBLE := $(shell pwd)/$(shell dirname $(SQLCIPHER)):$(LD_LIBRARY_PATH_NIMBLE)
endif

# for NCURSES, PCRE, SSL assume already in PATH of MSYS2 shell, e.g. in /mingw64/bin
PATH_NIMBLE := $${PATH}
ifeq ($(RLN_STATIC),false)
 PATH_NIMBLE := $(RLN_LIB_DIR):$(PATH_NIMBLE)
endif
ifeq ($(SQLCIPHER_STATIC),false)
 PATH_NIMBLE := $(shell pwd)/$(shell dirname $(SQLCIPHER)):$(PATH_NIMBLE)
endif

RUN_AFTER_BUILD ?= true

# MACOSX_DEPLOYMENT_TARGET="$(MACOSX_DEPLOYMENT_TARGET)" \

NIMBLE_ENV = \
	LOG_LEVEL=$(LOG_LEVEL) \
	NCURSES_LDFLAGS="$(NCURSES_LDFLAGS)" \
	NCURSES_STATIC=$(NCURSES_STATIC) \
	NIMSTATUS_CFLAGS="$(NIMSTATUS_CFLAGS)" \
	PCRE_LDFLAGS="$(PCRE_LDFLAGS)" \
	PCRE_STATIC=$(PCRE_STATIC) \
	RELEASE=$(RELEASE) \
	RLN_LDFLAGS="$(RLN_LDFLAGS)" \
	RLN_STATIC=$(RLN_STATIC) \
	RUN_AFTER_BUILD=$(RUN_AFTER_BUILD) \
	SQLCIPHER_LDFLAGS="$(SQLCIPHER_LDFLAGS)" \
	SSL_LDFLAGS="$(SSL_LDFLAGS)" \
	SSL_STATIC=$(SSL_STATIC) \
	WIN_STATIC=$(WIN_STATIC)
ifeq ($(detected_OS),Windows)
 NIMBLE_ENV += PATH="$(PATH_NIMBLE)"
else ifneq ($(detected_OS),macOS)
 NIMBLE_ENV += LD_LIBRARY_PATH="$(LD_LIBRARY_PATH_NIMBLE)"
endif

chat: $(SQLCIPHER) $(MIGRATIONS)
	$(NIMBLE_ENV) $(ENV_SCRIPT) nimble chat

waku_chat2: $(SQLCIPHER) $(MIGRATIONS)
	$(NIMBLE_ENV) $(ENV_SCRIPT) nimble waku_chat2

test: $(SQLCIPHER) $(MIGRATIONS)
	$(NIMBLE_ENV) $(ENV_SCRIPT) nimble tests

endif # "variables.mk" was not included