using REPL
REPL.activate(::Module)

using ReplMaker

function script_mode(filename, mod=(@eval module $(gensym(:Scratch)) end))
    initrepl(;prompt_text="Script> ", start_key=')', mode_name="Script mode", valid_input_checker=complete_julia) do s
        ex = Meta.parse(s)
        if ex.head == :block
            ex.head = :toplevel
        end
        open(filename, "a+") do io
            write(io, s*"\n\n")
        end
        :(@eval $mod $ex)
    end
    nothing
end

julia> script_mode("my_script.jl")
REPL mode Script mode initialized. Press ) to enter and backspace to exit.

Script> x = 1
1

Script> y = 2
2

Script> z = x + y
3

Script> function f(x)
            x + 1
        end
f (generic function with 1 method)

shell> cat my_script.jl
x = 1

y = 2

z = x + y

function f(x)
    x + 1
end

julia> x
ERROR: UndefVarError: x not defined

julia> y
ERROR: UndefVarError: y not defined

julia> z
ERROR: UndefVarError: z not defined

julia> f
ERROR: UndefVarError: f not defined

subrepl = REPL.LineEditREPL(REPL.TerminalMenus.terminal,
                            get(stdout, :color, false))
if subrepl.hascolor
    subrepl.prompt_color = Base.text_colors[:light_magenta]
end
subrepl.interface = REPL.setup_interface(subrepl)
(; hp) = first(subrepl.interface.modes[isa.(subrepl.interface.modes, REPL.LineEdit.HistoryPrompt)])
hp.mode_mapping[:julia].prompt = "(data) julia> "
hp.mode_mapping[:shell].prompt = "(data) shell> "
REPL.run_repl(subrepl)
lines = map(zip(hp.history, hp.modes)) do (line, mode)
    if mode == :julia
        line
        # Identify data""-y commands and extract to variables
    elseif mode == :shell
        "run(`$line`)"
    elseif mode == :help
        nothing
    else
        @warn "Mode $mode unrecognised"
        nothing
    end
end
content = string("# Formed by wrangle command\n",
                    "function ()\n",
                    join(filter(!isnothing, lines), "\n  "),
                    "\nend")

"""
    prompt(question::AbstractString, default::AbstractString="",
           allowempty::Bool=false, cleardefault::Bool=true)
Interactively ask `question` and return the response string, optionally
with a `default` value.

Unless `allowempty` is set an empty response is not accepted.
If `cleardefault` is set, then an initial backspace will clear the default value.

The prompt supports the following line-edit-y keys:
- left arrow
- right arrow
- home
- end
- delete forwards
- delete backwards

### Example

```julia-repl
julia> prompt("What colour is the sky? ")
What colour is the sky? Blue
"Blue"
```
"""
function prompt(question::AbstractString, default::AbstractString="";
                allowempty::Bool=false, cleardefault::Bool=true)
    printstyled(question, color=REPL_QUESTION_COLOR)
    get(stdout, :color, false) && print(Base.text_colors[REPL_USER_INPUT_COLOUR])
    REPL.Terminals.raw!(REPL.TerminalMenus.terminal, true)
    response = let response = collect(default)
        point = length(response)
        firstinput = true
        print("\e[s")
        while true
            print("\e[u\e[J")
            if String(response) == default
                print("\e[90m")
            end
            print(String(response))
            if point < length(response)
                print("\e[$(length(response) - point)D")
            end
            next = Char(REPL.TerminalMenus.readkey(REPL.TerminalMenus.terminal.in_stream))
            if next == '\r'  # RET
                if (!isempty(response) || allowempty)
                    print('\n')
                    break
                end
            elseif next == 'Ϭ' # DEL-forward
                if point < length(response)
                    deleteat!(response, point + 1)
                end
            elseif next == '\x03' # ^C
                print("\e[m^C\n")
                throw(InterruptException())
            elseif next == '\x7f' # DEL
                if firstinput && cleardefault
                    response = Char[]
                    point = 0
                elseif point > 0
                    deleteat!(response, point)
                    point -= 1
                end
            elseif next == 'Ϩ' # <left>
                point = max(0, point - 1)
            elseif next == 'ϩ' # <right>
                point = min(length(response), point + 1)
            elseif next == 'ϭ' # HOME
                point = 0
            elseif next == 'Ϯ' # END
                point = length(response)
            else
                point += 1
                insert!(response, point, next)
            end
            firstinput = false
        end
        String(response)
    end
    REPL.Terminals.raw!(REPL.TerminalMenus.terminal, false)
    get(stdout, :color, false) && print("\e[m")
    response
end

"""
    prompt_char(question::AbstractString, options::Vector{Char},
                default::Union{Char, Nothing}=nothing)
Interatively ask `question`, only accepting `options` keys as answers.
All keys are converted to lower case on input. If `default` is not nothing and
'RET' is hit, then `default` will be returned.

Should '^C' be pressed, an InterruptException will be thrown.
"""
function prompt_char(question::AbstractString, options::Vector{Char},
                     default::Union{Char, Nothing}=nothing)
    printstyled(question, color=REPL_QUESTION_COLOR)
    REPL.Terminals.raw!(REPL.TerminalMenus.terminal, true)
    char = '\x01'
    while char ∉ options
        char = lowercase(Char(REPL.TerminalMenus.readkey(REPL.TerminalMenus.terminal.in_stream)))
        if char == '\r' && !isnothing(default)
            char = default
        elseif char == '\x03' # ^C
            print("\e[m^C\n")
            throw(InterruptException())
        end
    end
    REPL.Terminals.raw!(REPL.TerminalMenus.terminal, false)
    get(stdout, :color, false) && print(Base.text_colors[REPL_USER_INPUT_COLOUR])
    print(stdout, char, '\n')
    get(stdout, :color, false) && print("\e[m")
    char
end

"""
    confirm_yn(question::AbstractString, default::Bool=false)
Interactively ask `question` and accept y/Y/n/N as the response.
If any other key is pressed, then `default` will be taken as the response.
A " [y/n]: " string will be appended to the question, with y/n capitalised
to indicate the default value.

### Example

```julia-repl
julia> confirm_yn("Do you like chocolate?", true)
Do you like chocolate? [Y/n]: y
true
```
"""
function confirm_yn(question::AbstractString, default::Bool=false)
    char = prompt_char(question * (" [y/N]: ", " [Y/n]: ")[1+ default],
                       ['y', 'n'], ('n', 'y')[1+default])
    char == 'y'
end

let mod = (@eval module $(gensym(:Scratch)) end)
    for s ∈ names(Main, all=true)
        if getproperty(Main, s) isa Module
            @eval mod using $s
        end
    end
end

using Foo: bar