#!/usr/bin/env bash

set -e

export XGCCPATH="${XGCCPATH:-$PWD/coreboot/util/crossgcc/xgcc/bin}"
export PATH="$XGCCPATH:$PATH:/usr/sbin"

if [ -z "$1" ]
then
  echo "$0 <model>" >&2
  exit 1
fi
MODEL="$1"

if [ ! -d "models/${MODEL}" ]
then
  echo "model '${MODEL}' not found" >&2
  exit 1
fi
MODEL_DIR="$(realpath "models/${MODEL}")"

DATE="$(git show --format="%cd" --date="format:%Y-%m-%d" --no-patch --no-show-signature)"
REV="$(git describe --always --dirty --abbrev=7)"
VERSION="${DATE}_${REV}"
echo "Building '${VERSION}' for '${MODEL}'"

# Path to edk2's Python script to generate UEFI capsules
GENERATE_CAPSULE="./edk2/BaseTools/BinWrappers/PosixLike/GenerateCapsule"

# Clean build directory
mkdir -p build
BUILD="$(realpath "build/${MODEL}")"
rm -rf "${BUILD}"
mkdir -p "${BUILD}"

UEFIPAYLOAD="${BUILD}/UEFIPAYLOAD.fd"
COREBOOT="${BUILD}/firmware.rom"
USB="${BUILD}/usb.img"
EDK2_ARGS=(
    -D SHELL_TYPE=NONE
    -D SOURCE_DEBUG_ENABLE=FALSE
)

# Rebuild firmware-setup (used by edk2)
touch apps/firmware-setup/Cargo.toml
make -C apps/firmware-setup
EDK2_ARGS+=(
    -D FIRMWARE_OPEN_FIRMWARE_SETUP="firmware-setup/firmware-setup.inf"
)

# Rebuild gop-policy (used by edk2)
if [ -e "${MODEL_DIR}/IntelGopDriver.inf" ] && [ -e "${MODEL_DIR}/vbt.rom" ]
then
    touch apps/gop-policy/Cargo.toml
    FIRMWARE_OPEN_VBT="${MODEL_DIR}/vbt.rom" \
        make -C apps/gop-policy
    EDK2_ARGS+=(
        -D FIRMWARE_OPEN_GOP_POLICY="gop-policy/gop-policy.inf"
        -D FIRMWARE_OPEN_GOP="IntelGopDriver.inf"
    )
fi

# Add any arguments in edk2.config
if [ -e "${MODEL_DIR}/edk2.config" ]
then
    while read line
    do
        if [ -n "$line" ] && [[ "$line" != "#"* ]]
        then
            EDK2_ARGS+=(-D "$line")
        fi
    done < "${MODEL_DIR}/edk2.config"
fi

# Source edk2 config for FMP values
. "$MODEL_DIR/edk2.config"

# Rebuild UefiPayloadPkg using edk2
PACKAGES_PATH="${MODEL_DIR}:$(realpath apps)" \
    ./scripts/_build/edk2.sh \
        "${UEFIPAYLOAD}" \
        "${EDK2_ARGS[@]}"

# Rebuild coreboot
FIRMWARE_OPEN_MODEL_DIR="${MODEL_DIR}" \
FIRMWARE_OPEN_UEFIPAYLOAD="${UEFIPAYLOAD}" \
KERNELVERSION="${VERSION}" \
    ./scripts/_build/coreboot.sh \
        "${MODEL_DIR}/coreboot.config" \
        "${COREBOOT}"

if [ "$MODEL" != "qemu" ]; then
    # Generate system firmware capsule
    SYSTEM_FMP_VERSION=1
    $GENERATE_CAPSULE -e \
        --guid "$SYSTEM_FMP_UUID" \
        --fw-version "$SYSTEM_FMP_VERSION" \
        --lsv 0 \
        -o "$BUILD/firmware.cap" \
        "$BUILD/firmware.rom"
fi

# Rebuild EC firmware for System76 EC models
if [ ! -e  "${MODEL_DIR}/ec.rom" ] && [ -e "${MODEL_DIR}/ec.config" ]
then
    env VERSION="${VERSION}" \
        ./scripts/_build/ec.sh \
        "${MODEL_DIR}/ec.config" \
        "${BUILD}/ec.rom"

    # Generate EC firmware capsule
    EC_FMP_VERSION=1
    $GENERATE_CAPSULE -e \
        --guid "$EC_FMP_UUID" \
        --fw-version "$EC_FMP_VERSION" \
        --lsv 0 \
        -o "$BUILD/ec.cap" \
        "$BUILD/ec.rom"
fi

if [ "${MODEL}" != "qemu" ]
then
    # Rebuild firmware-update
    export BASEDIR="system76_${MODEL}_${VERSION}"
    pushd apps/firmware-update >/dev/null
      rm -rf "build/x86_64-unknown-uefi"
      make "build/x86_64-unknown-uefi/boot.img"
      cp -v "build/x86_64-unknown-uefi/boot.img" "${USB}.partial"
    popd >/dev/null

    # Copy firmware to USB image
    mmd -i "${USB}.partial@@1M" "::${BASEDIR}/firmware"
    mcopy -v -i "${USB}.partial@@1M" "${COREBOOT}" "::${BASEDIR}/firmware/firmware.rom"
    if [ -e "${BUILD}/ec.rom" ]
    then
        mcopy -v -i "${USB}.partial@@1M" "${BUILD}/ec.rom" "::${BASEDIR}/firmware/ec.rom"
    elif [ -e "${MODEL_DIR}/ec.rom" ]
    then
        mcopy -v -i "${USB}.partial@@1M" "${MODEL_DIR}/ec.rom" "::${BASEDIR}/firmware/ec.rom"
    fi
    if [ -e "${MODEL_DIR}/uecflash.efi" ]
    then
        mcopy -v -i "${USB}.partial@@1M" "${MODEL_DIR}/uecflash.efi" "::${BASEDIR}/firmware/uecflash.efi"
    fi
    mv -v "${USB}.partial" "${USB}"
fi

echo "Built '${VERSION}' for '${MODEL}'"