from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, MultiFunction
from ..structs import *
from pathlib import Path
from glob import glob
from io import UnsupportedOperation
import sys

FS = Environment()

FS.register("_stdin_", Handle(sys.stdin))
FS.register("_stdout_", Handle(sys.stdout))
FS.register("_stderr_", Handle(sys.stderr))

def interpretExists(symbol, args, env, ns):
    return Bool(Path(args[0].value).resolve().exists())

exists_func = Builtin("exists?", interpretExists, [Arg("filename", TypeEnum.STRING)], return_type=Type(":bool"))
exists_multi = MultiFunction("exists?")
exists_multi.register(exists_func)
FS.register("exists?", exists_multi)

def interpretGlob(symbol, args, env, ns):
    items = glob(args[0].value)
    return List([String(item) for item in items])

glob_func = Builtin("glob", interpretGlob, [Arg("regex", TypeEnum.STRING)], return_type=Type(":string"))
glob_multi = MultiFunction("glob")
glob_multi.register(glob_func)
FS.register("glob", glob_multi)

def interpretUnlink(symbol, args, env, ns):
    target_path = Path(args[0].value).resolve()
    if not target_path.exists():
        raise InterpretPanic(symbol, "target file does not exist", target_path)
    target_path.unlink()
    return Nil()

unlink_func = Builtin("unlink", interpretUnlink, [Arg("filename", TypeEnum.STRING)], return_type=Type(":nil"))
unlink_multi = MultiFunction("unlink")
unlink_multi.register(unlink_func)
FS.register("unlink", unlink_multi)

def interpretWrite(symbol, args, env, ns):
    string = args[0]
    handle = args[1]
    try:
        handle.file.write(string.value)
    except UnsupportedOperation:
        raise InterpretPanic(symbol, f"{handle} is not writable!")
    except ValueError:
        raise InterpretPanic(symbol, f"{handle} is closed")
    return Nil()

write_func = Builtin("write", interpretWrite, [Arg("string", TypeEnum.STRING), Arg("handle", TypeEnum.HANDLE)], return_type=Type(":nil"))
write_multi = MultiFunction("write")
write_multi.register(write_func)
FS.register("write", write_multi)

def interpretOpenRead(symbol, args, env, ns):
    name = args[0].value
    fil = Path(name)
    if not fil.exists():
        raise InterpretPanic(symbol, "file does not exist", fil)
    try:
        f = open(str(fil), "r")
    except:
        raise InterpretPanic(symbol, "cannot open {fil} for reading")
    return Handle(f)

openread_func = Builtin("open-read", interpretOpenRead, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
openread_multi = MultiFunction("open-read")
openread_multi.register(openread_func)
FS.register("open-read", openread_multi)

def interpretOpenWrite(symbol, args, env, ns):
    name = args[0].value
    fil = Path(name)
    try:
        f = open(str(fil), "w")
    except:
        raise InterpretPanic(symbol, "cannot open {fil} for writing")
    return Handle(f)

openwrite_func = Builtin("open-write", interpretOpenWrite, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
openwrite_multi = MultiFunction("open-write")
openwrite_multi.register(openwrite_func)
FS.register("open-write", openwrite_multi)

def interpretOpenAppend(symbol, args, env, ns):
    name = args[0].value
    fil = Path(name)
    try:
        f = open(str(fil), "a")
    except:
        raise InterpretPanic(symbol, "cannot open {fil} for appending")
    return Handle(f)

openappend_func = Builtin("open-append", interpretOpenAppend, [Arg("filename", TypeEnum.STRING)], return_type=Type(":handle"))
openappend_multi = MultiFunction("open-append")
openappend_multi.register(openappend_func)
FS.register("open-append", openappend_multi)

def interpretClose(symbol, args, env, ns):
    try:
        args[0].file.close()
        # TODO ideally we'd be able to remove it from the env
        # but by this point, we don't know its symbol
        # though it may not be in the env, e.g.
        # (close (print (read (open-read "fil.txt"))))
    except:
        raise InterpretPanic(symbol, "cannot close {args[0]}")
    return Nil()

close_func = Builtin("close", interpretClose, [Arg("handle", TypeEnum.HANDLE)], return_type=Type(":nil"))
close_multi = MultiFunction("close")
close_multi.register(close_func)
FS.register("close", close_multi)

def interpretRead(symbol, args, env, ns):
    handle = args[0]
    try:
        inp = args[0].file.read()
    except UnsupportedOperation:
        raise InterpretPanic(symbol, f"{handle} is not writable!")
    except ValueError:
        raise InterpretPanic(symbol, f"{handle} is closed")
    return String(inp)

read_func = Builtin("read", interpretRead, [Arg("handle", TypeEnum.HANDLE)], return_type=Type(":string"))
read_multi = MultiFunction("read")
read_multi.register(read_func)
FS.register("read", read_multi)

def interpretReadLines(symbol, args, env, ns):
    target_file_name = args[0].value
    target_file = Path(target_file_name).resolve()
    if not target_file.exists():
        raise InterpretPanic(symbol, "no such file", target_file)
    with open(target_file, "r") as fil:
        data = fil.readlines()
    out = List([String(d) for d in data]) # all lines are strings
    return out

readlines_func = Builtin("read-lines", interpretReadLines, [Arg("filename", TypeEnum.STRING)], return_type=Type(":[]"))
readlines_multi = MultiFunction("read-lines")
readlines_multi.register(readlines_func)
FS.register("read-lines", readlines_multi)