#!/bin/sh
#  Copyright (C) 2010  Matias A. Fonzo, Santiago del Estero, Argentina
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Usage:
#
# If you want to build a whole section, type:
#   ./xorg-builder lib
#
# If you want to build a specific source of a section:
#   ./xorg-builder lib libX11

### URL: http://xorg.freedesktop.org/releases/

# Variables #

# Iniciales:
currentWorkDir=$(pwd)                 # Directorio actual de trabajo.

tempDir=${tempDir:-/tmp}              # Directorio temporal base.
outDir=${outDir:-/tmp/packages/xorg}  # Directorio de salida de los paquetes.

buildDir=${tempDir}/xorg-buildir      # Directorio temporal de construcción.

# Para el programa:
CFLAGS=${CFLAGS:=-O2 -march=i486 -mtune=i686}
CXXFLAGS=${CXXFLAGS:=-O2 -march=i486 -mtune=i686}

libSuffix=${libSuffix:-""}            # Sufijo exportado usualmente para x86_64.

Arch=${Arch:-i486}                    # Arquitectura.
buildNum=${buildNum:-1}               # Número de construcción.

numJobs=${numJobs:=-j5}               # Trabajos para el compilador.

# Funciones #

# Muestra la ayuda:
Usage()
{
    printf "%s\n" "" "Usage:" \
     "" \
     "If you want to build a whole section, type:" \
     "$0 lib" \
     "" \
     "If you want to build a specific source of a section:" \
     "$0 lib libX11" \
     ""
}

# Una función para crear directorios limpios:
CreateDirs()
{
    local X Y
    X="$1"
    Y="$2"
    rm -rf $X
    mkdir -p $X $Y
}

# Corrige los permisos de la fuente:
FixPermissions()
{
    chown -R 0:0 "$1"
    find . \
     \( -perm 2777 -o \
        -perm 777  -o \
        -perm 775  -o \
        -perm 711  -o \
        -perm 555  -o \
        -perm 511     \
     \) -exec chmod 755 {} + \
      -o \
     \( -perm 666 -o \
        -perm 664 -o \
        -perm 600 -o \
        -perm 444 -o \
        -perm 440 -o \
        -perm 400    \
     \) -exec chmod 644 {} +
}

# Corrige las locaciones de los directorios de documentación:
FixDocDirs()
{
    # Movemos los directorios de documentación puesto que
    # no queremos dichos directorios bajo usr/share:
    for Directory in man info doc ; do
      if [ -d usr/share/${Directory} ]; then
        mv usr/share/${Directory} usr/${Directory}
      fi
    done
    rmdir usr/share 2> /dev/null
}

# Función para comprimir y enlazar (si es necesario) las páginas de manual:
CompressAndLinkManpages()
{
    if [ -d usr/man ]; then
      (
        cd usr/man
        find . -type f -exec gzip -9N '{}' +
        find . -type l | while read File ; do
          ln -sf $(readlink $File).gz ${File}.gz
          rm $File
        done
      )
    fi
}

# Función que copia las páginas de información de GNU:
CompressInfoPages()
{
    if [ -d usr/info ]; then
      rm -f usr/info/dir
      gzip -9N usr/info/*
    fi
}

# Función que copia los archivos de documentación:
CopyDocumentation()
{
    # Crea el directorio de documentación y busca para copiar los archivos:
    mkdir -p usr/doc/${sourceName}-${sourceVersion}
    for File in AUTHORS COPYING ChangeLog NEWS README ; do
      if [ -f ${buildDir}/${sourceName}-${sourceVersion}/$File ]; then
        cp -pP \
         ${buildDir}/${sourceName}-${sourceVersion}/$File \
         usr/doc/${sourceName}-${sourceVersion}
      fi
    done
    # Algunas fuentes instalan el directorio de documentación con sólo el
    # nombre de la fuente.  Cuando nosotros, lo que queremos, es tener el
    # directorio de documentación bajo <nombre_programa>-<versión>:
    if [ -d ${packageDir}/usr/doc/${sourceName} ]; then
      mv ${packageDir}/usr/doc/${sourceName}/* usr/doc/${sourceName}-${sourceVersion}
      rmdir ${packageDir}/usr/doc/${sourceName} 2> /dev/null
    fi
}

## Cuerpo de la receta ##

cd src || exit 99;  # Ingresa o sale del directorio que contiene las fuentes.

export CFLAGS CXXFLAGS libSuffix

for Directory in doc proto lib data app xserver driver font util ; do
    # Comprueba el primer argumento:
    if [ -n "$1" ]; then
      if [ "$1" != $Directory ]; then
        continue;
      fi
    else  # Imprime la ayuda:
      Usage
      exit;
    fi

    # Variable del directorio del paquete (de toda una sección):
    packageDir=${buildDir}/package-${Directory}

    # Crea el directorio del paquete y el de salida:
    CreateDirs "$packageDir" "$outDir"

    # Tomamos los datos que necesitamos de cada fuente para construir el paquete:
    for Tarball in ${Directory}/*.tar.lz ; do
      sourceName="$(basename $Tarball .tar.lz)"
      sourceVersion="${sourceName##*-}"
      sourceName="${sourceName%-*}"

      # Verifica el nombre de la fuente en la lista-negra:
      if grep -qw "$sourceName" ${currentWorkDir}/BLACKLIST 2> /dev/null ; then
        continue;
      fi

      # Verifica la lista de las fuentes que poseen una arquitectura independiente:
      archPackage=$Arch  # Resetea la variable.
      if grep -q "^${sourceName}" ${currentWorkDir}/NOARCHLIST 2> /dev/null ; then
        archPackage=noarch
      fi

      # Comprueba el segundo argumento:
      if [ -n "$2" ]; then
        if [ "$2" = "${sourceName}" ] || [ "$2" = "$Tarball" ]; then
          # Asigna el directorio del paquete:
          packageDir=${buildDir}/package-${sourceName}
          CreateDirs "$packageDir" "$outDir"
        else
          continue;
        fi

        # Comprueba si el segundo argumento está incluido en la lista esperada:
        if [ -f ${currentWorkDir}/BUILDLIST ]; then
          if ! grep -q "^${Directory}/$sourceName" ${currentWorkDir}/BUILDLIST ; then
            continue;
          fi
        fi
      fi

      (
        # Hora de construir la fuente:
        cd $buildDir

        # Descomprime el tarball:
        rm -rf ${sourceName}-${sourceVersion}
        lzip -cd ${currentWorkDir}/src/$Tarball | tar -xvf -

        # Ingresamos al directorio de la fuente y lo purgamos:
        cd ${sourceName}-${sourceVersion}
        FixPermissions .

        # Si es necesario aplicamos un parche:
        if [ -x ${currentWorkDir}/patches/${sourceName} ]; then
          . ${currentWorkDir}/patches/${sourceName}
        fi

        # Configuramos la fuente:

        # Determina el tipo de sistema donde se construye.
        if [ "$archPackage" != "noarch" ]; then
          BUILD_SYSTEM="--build=${Arch}-dragora-linux-gnu"
        fi

        # Si es necesario usamos un `configure' personalizado:
        if [ -f ${currentWorkDir}/configure/${sourceName} ]; then
          . ${currentWorkDir}/configure/${sourceName}
        else  # Usa el `configure' por defecto:
          . ${currentWorkDir}/configure/default
        fi

        # Ahora -- construimos:
        make $numJobs || make || exit 99;
        make install DESTDIR=$packageDir

        # Purgamos los binarios y las librerías para una buena medida:
        (
          cd $packageDir
          find . -type f | xargs file | awk '/ELF/ && /executable/ || /shared object/' | \
           cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
          find . -type f | xargs file | awk '/current ar archive/' | \
           cut -f 1 -d : | xargs strip --strip-debug 2> /dev/null
        )

        # Si es necesario recurrimos a pasos adicionales:
        if [ -x "${currentWorkDir}/postmake/${sourceName}" ]; then
          . "${currentWorkDir}/postmake/${sourceName}"
        fi

        # Comprimimos, enlazamos y copiamos para el resto de nuestro paquete:
        cd $packageDir

        FixDocDirs
        CompressInfoPages
        CompressAndLinkManpages
        CopyDocumentation

        # Introducimos los archivos de descripción:
        if [ -d ${currentWorkDir}/descriptions/$sourceName ]; then
          mkdir -p description/
          cp ${currentWorkDir}/descriptions/${sourceName}/* ${packageDir}/description/
        else  # Reportar descripción perdida:
          echo "$sourceName" >> ${currentWorkDir}/missing.descriptions
        fi

        # Determina el número de construcción para el paquete. Según,
        # indicaciones en un archivo o de la variable ya establecida:
        if [ -f ${currentWorkDir}/buildnum/$sourceName ]; then
          buildNum=$(cut -f 1 -d ' ' ${currentWorkDir}/buildnum/${sourceName})
        fi

        # Hacemos el paquete:
        if [ -x ${currentWorkDir}/makepkg/$sourceName ]; then
          . ${currentWorkDir}/makepkg/$sourceName
        else
          makepkg -l \
           ${outDir}/${sourceName}-${sourceVersion}-${archPackage}-${buildNum}.tlz
        fi
      )
    done
done