from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic
from ..structs import *
from pathlib import Path
from glob import glob

FS = Environment()

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

FS.register("exists?", Builtin("exists?", interpretExists, [Arg("filename", TypeEnum.STRING)]))

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

FS.register("glob", Builtin("glob", interpretGlob, [Arg("regex", TypeEnum.STRING)]))

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 List([])

FS.register("unlink", Builtin("unlink", interpretUnlink, [Arg("filename", TypeEnum.STRING)]))

def interpretWithWrite(symbol, args, env, ns):
    target_file = args[0]
    new_env = Environment(env)
    target_path = Path(target_file.value).resolve()
    ret = Literal([])
    with open(str(target_path), "w") as fil:
        new_env.register("_file_", List([fil])) # TODO wrong!
        for arg in args[1:]:
            ret = evaluate(arg, new_env, ns)
    return ret

FS.register("with-write", Builtin("with-write", interpretWithWrite, [Arg("filename", TypeEnum.STRING)], Arg("exprs", TypeEnum.ANY, lazy=True)))

def interpretWrite(symbol, args, env, ns):
    # write :string :filehandle
    line = args[0]
    handle = args[1]
    handle.args[0].write(line.value)  # TODO wrong! how do we evaluate a handle?
    return Literal([])

FS.register("write", Builtin("write", interpretWrite, [Arg("string", TypeEnum.STRING), Arg("filename", TypeEnum.LIST)]))

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

FS.register("read-lines", Builtin("read-lines", interpretReadLines, [Arg("filename", TypeEnum.STRING)]))