import os
import sys
import time

#!/usr/bin/env python3

def main():
    PROG = os.path.basename(__file__)
    if len(sys.argv) < 5:
        ogRaiseError("session", OG_ERR_FORMAT, f"{MSG_FORMAT}: {PROG} REPO imagen ndisco nparticion [ UNICAST-DIRECT|UNICAST|UNICAST-CACHE|MULTICAST-DIRECT|MULTICAST|MULTICAST-CACHE|TORRENT [opciones protocolo] ]")
        sys.exit(1)

    TIME1 = time.time()
    REPO = sys.argv[1].upper() or "REPO"
    IMGNAME = sys.argv[2]
    DISK = sys.argv[3]
    PART = sys.argv[4]
    PROTO = (sys.argv[5].upper() if len(sys.argv) > 5 else "UNICAST")
    PROTOOPT = sys.argv[6] if len(sys.argv) > 6 else ""
    OGUNIT = os.getenv("ogunit", "")

    if not OGENGINECONFIGURATE:
        exec(open("/opt/opengnsys/etc/engine.cfg").read())

    with open(OGLOGCOMMAND, 'w') as f:
        f.write(" ")
    if ogGetCaller() != "EjecutarScript":
        with open(OGLOGSESSION, 'w') as f:
            f.write("")

    ogEcho("log", "session", f"[1] {MSG_SCRIPTS_START} {PROG} {' '.join(sys.argv)}")

    if ogIsLocked(DISK, PART):
        sys.exit(ogRaiseError("session", OG_ERR_LOCKED, f"{MSG_PARTITION}, {DISK} {PART}"))

    ogEcho("log", "session", f"{MSG_HELP_ogUnmount} {DISK} {PART}")
    ogUnmount(DISK, PART)

    if REPO == ogGetIpAddress() or REPO == "CACHE":
        MODE = "CACHE"
    else:
        if ogCheckIpAddress(REPO) == 0 or REPO == "REPO":
            if not ogChangeRepo(REPO, OGUNIT):
                sys.exit(ogRaiseError(OG_ERR_NOTFOUND, f"{REPO} {OGUNIT}"))
            MODE = "REPO"

    IMGOS = ogGetImageInfo(ogGetPath(MODE, f"{IMGNAME}.img"))
    if IMGOS == 1:
        sys.exit(ogRaiseError("session", OG_ERR_NOTFOUND, f"{REPO} {IMGNAME}"))
    elif IMGOS == 5:
        sys.exit(ogRaiseError("session", OG_ERR_IMAGEFILE, f"{REPO} {IMGNAME}"))
    elif IMGOS != 0:
        sys.exit(ogRaiseError("session", OG_ERR_GENERIC))

    IMGSIZE = os.path.getsize(ogGetPath(MODE, f"{IMGNAME}.img")) // 1024
    ogEcho("log", "session", f"[1] REPO={REPO} IMG-FILE={IMGNAME}.img SIZE={IMGSIZE} (KB) METADATA={IMGOS}")

    if MODE == "CACHE":
        NEXTOPERATION = "CACHE"
    elif MODE == "REPO":
        if PROTO in ["MULTICAST-DIRECT", "UNICAST-DIRECT"]:
            NEXTOPERATION = PROTO.split('-')[0]
        elif PROTO in ["TORRENT", "TORRENT-CACHE", "MULTICAST", "MULTICAST-CACHE", "UNICAST", "UNICAST-CACHE"]:
            PROTO = PROTO.split('-')[0]
            ogEcho("log", "session", f"[2] updateCache {REPO} /{IMGNAME}.img {PROTO} {PROTOOPT}")
            TIME2 = time.time()
            RETVAL = updateCache(REPO, f"/{IMGNAME}.img", PROTO, PROTOOPT)
            TIME2 = time.time() - TIME2
            ogEcho("log", "session", f"   [ ]  {MSG_SCRIPTS_TIME_PARTIAL} updateCache {TIME2 // 60}m {TIME2 % 60}s")
            if RETVAL == 0:
                ogEcho("log", "session", "[50] updateCache (OK)")
                NEXTOPERATION = "CACHE"
            elif RETVAL in [15, 16]:
                ogEcho("log", "session", f"[50] {MSG_ERR_NOTCACHE} ;  {MSG_ERR_CACHESIZE}")
                ogEcho("log", "session", f"[50] {MSG_SCRIPTS_CHECK_ENGINE}:  RESTOREPROTOCOLNOTCACHE={RESTOREPROTOCOLNOTCACHE}")
                if RESTOREPROTOCOLNOTCACHE == "MULTICAST":
                    NEXTOPERATION = "MULTICAST" if PROTO == "MULTICAST" else "UNICAST"
                elif RESTOREPROTOCOLNOTCACHE == "UNICAST":
                    NEXTOPERATION = "UNICAST"
                elif RESTOREPROTOCOLNOTCACHE == "NONE":
                    if RETVAL == 15:
                        ogEcho("log", "session", f"[100] {MSG_ERR_NOTCACHE}")
                        sys.exit(ogRaiseError("session", OG_ERR_NOTCACHE, "NOT CACHE"))
                    elif RETVAL == 16:
                        ogEcho("log", "session", f"[100]  {MSG_ERR_CACHESIZE}")
                        sys.exit(ogRaiseError("session", OG_ERR_CACHESIZE, "CACHE FULL"))
            elif RETVAL in [57, 60]:
                sys.exit(RETVAL)
            else:
                sys.exit(RETVAL)
        else:
            sys.exit(ogRaiseError("session", OG_ERR_FORMAT, f"{MSG_ERR_FORMAT}, {PROTO}"))
    else:
        sys.exit(ogRaiseError("session", OG_ERR_FORMAT, f"{MSG_ERR_FORMAT}, {REPO}"))

    TIME3 = time.time()

    if NEXTOPERATION == "CACHE":
        PARAMS = f"CACHE {IMGNAME} {DISK} {PART}"
    elif NEXTOPERATION == "UNICAST":
        PARAMS = f"{REPO} {IMGNAME} {DISK} {PART}"
    elif NEXTOPERATION == "MULTICAST":
        PARAMS = f"{REPO} {IMGNAME} {DISK} {PART} {PROTO} {PROTOOPT}"

    if os.system("which restoreImageCustom") == 0:
        ogEcho("log", "session", f"[55] {MSG_HELP_ogRestoreImage}: restoreImageCustom {PARAMS}")
        os.system(f"restoreImageCustom {PARAMS}")
    else:
        ogEcho("log", "session", f"[55] {MSG_HELP_ogRestoreImage}: restoreImage {PARAMS}")
        os.system(f"restoreImage {PARAMS}")
    RETVAL = os.system(f"restoreImage {PARAMS}")

    RESUMERESTOREIMAGE = os.popen(f"grep -m 1 'Total Time:' {OGLOGCOMMAND}").read()
    ogEcho("log", "session", f"   [ ]      {RESUMERESTOREIMAGE}")
    if RETVAL != 0:
        ogRaiseError("session", OG_ERR_IMAGE, f"{REPO} {IMGNAME}")
        if ogGetCaller() != "EjecutarScript":
            ogEcho("log", "session", f"{MSG_INTERFACE_END} {OG_ERR_IMAGE}")
        sys.exit(OG_ERR_IMAGE)

    TIME3 = time.time() - TIME3
    ogEcho("log", "session", f"   [ ]      {MSG_SCRIPTS_TIME_PARTIAL} : {TIME3 // 60}m {TIME3 % 60}s")

    if os.system("which configureOsCustom") == 0:
        ogEcho("log", "session", "[90] configureOsCustom")
        os.system(f"configureOsCustom {DISK} {PART} {REPO} {IMGNAME}")
    else:
        ogEcho("log", "session", f"[90] {MSG_SCRIPTS_OS_CONFIGURE}")
        os.system(f"configureOs {DISK} {PART}")

    TIME = time.time() - TIME1
    ogEcho("log", "session", f"[100] {MSG_SCRIPTS_TIME_TOTAL} {TIME // 60}m {TIME % 60}s")

    if ogGetCaller() != "EjecutarScript":
        ogEcho("log", "session", f"{MSG_INTERFACE_END} {RETVAL}")
        sys.exit(RETVAL)

if __name__ == "__main__":
    main()