#!/usr/bin/python3

import os
import sys

import ogGlobals
import SystemLib
import CacheLib
import FileSystemLib
import DiskLib
import InventoryLib

#Load engine configurator from engine.cfg file.
#Carga el configurador del engine desde el fichero engine.cfg
## (ogGlobals se encarga)

# Clear temporary file used as log track by httpdlog
# Limpia los ficheros temporales usados como log de seguimiento para httpdlog
open (ogGlobals.OGLOGSESSION,        'w').close()
open (ogGlobals.OGLOGCOMMAND,        'w').close()
open (ogGlobals.OGLOGCOMMAND+'.tmp', 'w').close()

# Registro de inicio de ejecución
SystemLib.ogEcho (['log', 'session'], None, f'{ogGlobals.lang.MSG_INTERFACE_START} {sys.argv}')

# Solo ejecutable por OpenGnsys Client.
#path = os.getenv('PATH')
#if path:
#    os.environ['PATH'] = f"{path}:{os.path.dirname(__name__)}"
prog = os.path.basename(__name__)

#____________________________________________________________________
#
# El parámetro $2 es el que aporta toda la información y el $1 se queda obsoleto
# Formato de entrada:
#        dis=Número de disco
#        != caracter de separación
#
#   Y un numero indeterminado de cadenas del tipo siguuenteseparadas por el caracter '$':
#        par=Número de particion*cod=Código de partición*sfi=Sistema de ficheros*tam=Tamaño de la partición*ope=Operación
#        @= caracter de separación
#____________________________________________________________________

# Captura de parámetros (se ignora el 1er parámetro y se eliminan espacios y tabuladores).
#param='dis=1!par=1*cpt=NTFS*sfi=NTFS*tam=11000000*ope=0%'
#param = ''.join(sys.argv[2:]).replace(' ', '').replace('\t', '')
param = sys.argv[2]

# Leer los dos bloques de parámetros, separados por '!'.
tbprm = param.split ('!')
pparam = tbprm[0]  # General disk parameters
sparam = tbprm[1]  # Partitioning and formatting parameters
is_there_cache = 'CACHE' in sparam

# Toma valores de disco y caché, separados por "*".
# Los valores están en las variables $dis: disco, $che: existe cache (1, 0), $tch: Tamaño de la cache.
pparams = pparam.split ('*')
dis = tch = None
for item in pparams:
    if '=' not in item: continue

    k, v = item.split ('=', 1)
    if k not in ['dis']:
        print (f'ignoring unknown disk parameter ({k})')
        continue

    if 'dis' == k: dis = int (v)

# Error si no se define el parámetro de disco (dis).
if dis is None:
    sys.exit (ogGlobals.OG_ERR_FORMAT)

# Toma valores de distribución de particiones, separados por "%".
tbp = []  # Valores de configuración (parámetros para ogCreatePartitions)
tbf = {}  # Tabla de formateo

sparams = sparam.split('%')

maxp=0
sum_tam = 0
do_sum_tam = True
cache_seen = extended_seen = False
for item in sparams:
    if not item: continue         ## por si nos pasan un '%' al final de todo
        # Leer datos de la partición, separados por "*".
    par = cpt = sfi = tam = None
    ope = 0
    for c in item.split ('*'):
        if '=' not in c: continue

        k, v = c.split ('=', 1)
        if k not in ['par', 'cpt', 'sfi', 'tam', 'ope']:
            print (f'ignoring unknown partition parameter ({k})')
            continue

        if   'par' == k: par = int (v)
        elif 'cpt' == k: cpt = v
        elif 'sfi' == k: sfi = v
        elif 'tam' == k: tam = int (v)
        elif 'ope' == k: ope = int (v)

    missing_params = []
    if par is None or 'None' == par: missing_params.append ('par')
    if cpt is None or 'None' == cpt: missing_params.append ('cpt')
    if sfi is None or 'None' == sfi: missing_params.append ('sfi')
    if tam is None or 'None' == tam: missing_params.append ('tam')
    if missing_params:
        print (f'partition data ({item}) missing required parameters ({' '.join (missing_params)})')
        sys.exit (1)

        # Componer datos de particionado.
    if 'CACHE' == cpt:
        if cache_seen:
            SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_FORMAT, f'se ha solicitado más de una partición de cache')
            sys.exit (1)
        cache_seen = True
        tch = tam
    else:
        tbp.append (f'{cpt}:{tam}')
        if do_sum_tam:
            sum_tam += tam
        if 'EXTENDED' == cpt:
            if extended_seen:
                SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_FORMAT, f'se ha solicitado más de una partición extendida')
                sys.exit (1)
            extended_seen = True
            do_sum_tam = False      ## don't sum sizes anymore

    if ope:
        # Si se activa operación de formatear, componer datos de formateo.
        if cpt not in ['EMPTY', 'EXTENDED', 'LINUX-LVM', 'LVM', 'ZPOOL']:
            tbf[par] = sfi
        # Obtener la partición mayor.
    if par > maxp: maxp = par

if tch is None:
    tch = 0

if is_there_cache and 0 == tch:
    print (f'nati ===================== is_there_cache ({is_there_cache}) tch ({tch}), this should not happen')



if not cache_seen and not tbp:
    SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'No se ha solicitado ninguna partición')
    sys.exit (1)

cur_ptt = DiskLib.ogGetPartitionTableType (dis)
ptt = 'GPT' if InventoryLib.ogIsEfiActive() else 'MSDOS'
recreate_partition_table = False
if not cur_ptt:
    SystemLib.ogEcho (['session', 'log'], None, f'No partition table--will create a "{ptt}" one')
    recreate_partition_table = True
if cur_ptt and ptt != cur_ptt:
    SystemLib.ogEcho (['session', 'log'], None, f'Current partition table type "{cur_ptt}" is wrong for this system--will replace it for a "{ptt}" one')
    recreate_partition_table = True


## size check: check that cache fits in the space left by the previously existing partitions
if not recreate_partition_table and not CacheLib.ogCheckNewCacheSize (dis, tch):
    SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_CACHE, f'nueva partición de caché no cabe en el hueco actual')
    sys.exit (1)

## size check: check that the newly defined partitions fit in the space left by the newly defined cache
disk_sectors = DiskLib.ogGetLastSector (dis)
IOSIZE = DiskLib.ogGetIoSize (dis)
if not IOSIZE:
    SystemLib.ogRaiseError ([], ogGlobals.OG_ERR_FORMAT, f'Failed to get disk sector size')
    sys.exit (1)
if 512 == IOSIZE:
    sum_tam_sectors = sum_tam*2
    cache_sectors = tch*2
else:
    sum_tam_sectors = (sum_tam+3)//4    ## sumamos 3 para que la división entera "redondee al alza"
    cache_sectors = (tch+3)//4
## esta comprobacion puede dejar pasar situaciones que más tarde dan error
## la ventana es bastante estrecha, y sumando aquí simplemente un 1 por 1000, ya la cerramos del todo
sum_tam_sectors = int (sum_tam_sectors * 1.001)
space_left_by_cache = disk_sectors - cache_sectors
if sum_tam_sectors > space_left_by_cache:
    SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_CACHE, f'las particiones no caben en el disco')
    sys.exit (1)

#____________________________________________________
#
# Proceso
#____________________________________________________
# Tamaño actual de la cache
CACHESIZE=CacheLib.ogGetCacheSize()

# Desmonta todas las particiones y la caché

SystemLib.ogEcho (['session', 'log'], None, f'[10] {ogGlobals.lang.MSG_HELP_ogUnmountAll}')
FileSystemLib.ogUnmountAll (dis)
CacheLib.ogUnmountCache()

if recreate_partition_table:
    DiskLib.ogDeletePartitionTable (dis)
    SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGPYFUNCS}/ogUpdatePartitionTable'])
    DiskLib.ogCreatePartitionTable (dis, ptt)

# Inicia la cache.
if is_there_cache:
    SystemLib.ogEcho (['session', 'log'], None, f'[30] {ogGlobals.lang.MSG_HELP_ogCreateCache}')
    SystemLib.ogEcho (['session', 'log'], None, f'   initCache.py {tch}')
    rc = SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGSCRIPTS}/initCache.py', str (tch)])
    if not rc:
        SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_CACHE, f'initCache.py failed')
        sys.exit (1)

# Definir particionado.
SystemLib.ogEcho (['session', 'log'], None, f'[50] {ogGlobals.lang.MSG_HELP_ogCreatePartitions}')
SystemLib.ogEcho (['session', 'log'], None, f'   ogCreatePartitions {dis} {' '.join (tbp)}')
res = SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGPYFUNCS}/ogCreatePartitions', str(dis)] + tbp)
if not res:
    SystemLib.ogRaiseError (['log', 'session'], ogGlobals.OG_ERR_GENERIC, f'ogCreatePartitions {dis} {' '.join (tbp)}')
    sys.exit (1)
SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGPYFUNCS}/ogUpdatePartitionTable'])

#  Formatear particiones
SystemLib.ogEcho (['session', 'log'], None, f'[70] {ogGlobals.lang.MSG_HELP_ogFormat}')
retval = 0
for p in range (1, maxp+1):
    if p not in tbf: continue
    if 'CACHE' == tbf[p]:
        if CACHESIZE == tch:    # Si el tamaño es distinto ya se ha formateado.
            SystemLib.ogEcho (['session', 'log'], None, '   ogFormatCache')
            retval = SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGPYFUNCS}/ogFormatCache'])
    else:
        SystemLib.ogEcho (['session', 'log'], None, f'   ogFormatFs {dis} {p} {tbf[p]}')
        retval = SystemLib.ogExecAndLog ('command', [f'{ogGlobals.OGPYFUNCS}/ogFormatFs', str(dis), str(p), tbf[p]])
        if not retval:
            SystemLib.ogRaiseError (['session', 'log'], ogGlobals.OG_ERR_GENERIC, f'ogFormatFs  {dis} {p} {tbf[p]}')
            sys.exit (1)
# Registro de fin de ejecución
SystemLib.ogEcho (['session', 'log'], None, f'{ogGlobals.lang.MSG_INTERFACE_END} {retval}')

#___________________________________________________________________
#
# Retorno
#___________________________________________________________________

sys.exit (0)