## Modified from
## https://github.com/SciML/SciMLTutorials.jl/blob/master/src/SciMLTutorials.jl


const repo_directory = joinpath(@__DIR__,"..")
const cssfile =   joinpath(@__DIR__, "..", "templates", "skeleton_css.css")
const htmlfile =  joinpath(@__DIR__, "..", "templates", "bootstrap.tpl")
const latexfile = joinpath(@__DIR__, "..", "templates", "julia_tex.tpl")

function build_toc(force=true)
    @info "building table of contents"

    jmd_dir = joinpath(repo_directory, "CwJ", "misc")
    build_dir = joinpath(@__DIR__, "build")
    isdir(build_dir) || mkpath(build_dir)

    file = joinpath(jmd_dir, "toc.jmd")

    outfile = joinpath(build_dir, "index.html")

    cd(jmd_dir)

    build_file(file, outfile, force=force) || return nothing

    header = CalculusWithJulia.WeaveSupport.header_cmd
    #footer = CalculusWithJulia.WeaveSupport.footer_cmd(bnm, folder)
    html_content = md2html(file,
                           header_cmds=(header,),
                           footer_cmds=()
                           )

    open(outfile, "w") do io
        write(io, html_content)
    end

    # to use weave, not pluto
    # weave(file;
    #       out_path=outfile,
    #       doctype="md2html",
    #       fig_ext=".svg",
    #       template=htmlfile,
    #       fig_path=tempdir())
end



# do we build the file?
function build_file(jmdfile, outfile; force=false)
    force && return true
    !isfile(outfile) && return true
    mtime(outfile) < mtime(jmdfile) && return true
    return false
end

# build list ⊂ (:script,:html,:weave_html, :pdf,:github,:notebook,:pluto)
function weave_file(folder, file; build_list=(:html,), force=false, kwargs...)

    jmd_dir = isdir(folder) ? folder : joinpath(repo_directory, "CwJ", folder)
    jmd_file = joinpath(jmd_dir, file)
    bnm = replace(basename(jmd_file), r".jmd$" => "")
    build_dir = joinpath(@__DIR__, "build")
    isdir(build_dir) || mkpath(build_dir)

    if !force
        #testfile = joinpath(repo_directory, "html", folder, bnm*".html")
        testfile = joinpath(build_dir, folder, bnm*".html")
        if isfile(testfile) && (mtime(testfile) >= mtime(tmp))
            return
        end
        force=true
    end


    Pkg.activate(dirname(jmd_dir))
    Pkg.instantiate()
    args = Dict{Symbol,String}(:folder=>folder,:file=>file)

    if :script ∈ build_list
        println("Building Script")
        dir = joinpath(repo_directory,"script",folder)
        isdir(dir) || mkpath(dir)

        ext = ".jl"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing

        args[:doctype] = "script"
        tangle(tmp;out_path=dir)
    end

    # use Pluto to build html pages
    if :html ∈ build_list
        ## use jmd -> pluto notebook -> generate_html
        println("Building HTML: $file")
        cd(jmd_dir)

        dir = joinpath(build_dir, folder)
        isdir(dir) || mkpath(dir)

        ext = ".html"
        outfile = joinpath(dir, bnm*ext)
        o = build_file(file, outfile, force=force)
        o || return nothing

        header = CalculusWithJulia.WeaveSupport.header_cmd
        footer = CalculusWithJulia.WeaveSupport.footer_cmd(bnm, folder)
        html_content = md2html(file,
                               header_cmds=(header,),
                               footer_cmds=(footer,)
                               )

        open(outfile, "w") do io
            write(io, html_content)
        end

    end

    ## old html generation
    if :weave_html ∈ build_list
        println("Building HTML for $file")
        dir = joinpath(build_dir, folder)
        isdir(dir) || mkpath(dir)

        figdir = joinpath(jmd_dir,"figures")
        htmlfigdir = joinpath(dir, "figures")

        if isdir(figdir)
            isdir(htmlfigdir) && rm(htmlfigdir, recursive=true)
            cp(figdir, htmlfigdir)
        end

        ext = ".html"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing


        Weave.set_chunk_defaults!(:wrap=>false)
        args[:doctype] = "html"



        # override printing for Polynomials, SymPy with weave
        𝐦 = Core.eval(@__MODULE__, :(module $(gensym(:WeaveHTMLTestModule)) end))
        Core.eval(𝐦, quote
using SymPy, Polynomials
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
    #write(io, "<div class=\"well well-sm\">")
    write(io, "<div class=\"output\">")
    show(io, "text/latex", x)
    write(io, "</div>")
end

function Base.show(io::IO, ::MIME"text/html", x::Array{T}) where {T <: SymPy.SymbolicObject}
    #write(io, "<div class=\"well well-sm\">")
    write(io, "<div class=\"output\">")
    show(io, "text/latex", x)
    write(io, "</div>")
end

function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: Polynomials.AbstractPolynomial}
#     #write(io, "<div class=\"well well-sm\">")
     write(io, "<div class=\"output\">")
     show(io, "text/latex", x)
     write(io, "</div>")
end

                  end)

        #weave(tmp,doctype = "md2html",out_path=dir,args=args; fig_ext=".svg", css=cssfile, kwargs...)
        weave(tmp;
              doctype = "md2html",
              out_path=dir,
              mod = 𝐦,
              args=args,
              fig_ext=".svg",
              template=htmlfile,
              fig_path=tempdir(),
              kwargs...)

        # clean up
        isdir(htmlfigdir) && rm(htmlfigdir, recursive=true)

    end

    if :pdf ∈ build_list

        eval(quote using Tectonic end) # load Tectonic; wierd testing error

        println("Building PDF")
        dir = joinpath(repo_directory,"pdf",folder)
        isdir(dir) || mkpath(dir)

        ext = ".pdf"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing



        fig_path = "_figures_" * bnm
        figdir = joinpath(jmd_dir,"figures")
        texfigdir = joinpath(dir, "figures")

        if isdir(figdir)
            isdir(texfigdir) && rm(texfigdir, recursive=true)
            cp(figdir, texfigdir)
        end

        args[:doctype] = "pdf"
        try
            weave(tmp,doctype="md2tex",out_path=dir,args=args;
                  template=latexfile,
                  fig_path=fig_path,
                  kwargs...)

            texfile = joinpath(dir, bnm * ".tex")
            Base.invokelatest(Tectonic.tectonic, bin -> run(`$bin $texfile`))


            # clean up
            for ext in (".tex",)
                f = joinpath(dir, bnm * ext)
                isfile(f) && rm(f)
            end

        catch ex
            @warn "PDF generation failed" exception=(ex, catch_backtrace())

        end

        isdir(texfigdir) && rm(texfigdir, recursive=true)
        isdir(joinpath(dir,fig_path)) && rm(joinpath(dir,fig_path), recursive=true)
        for ext in (".aux", ".log", ".out")
            f = joinpath(dir, bnm * ext)
            isfile(f) && rm(f)
        end

    end

    if :github ∈ build_list
        println("Building Github Markdown")
        dir = joinpath(repo_directory,"markdown",folder)
        isdir(dir) || mkpath(dir)


        ext = ".md"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing

        args[:doctype] = "github"
        weave(tmp,doctype = "github",out_path=dir, args=args;
              fig_path=tempdir(),
              kwargs...)
    end

    if :notebook ∈ build_list
        println("Building Notebook")
        dir = joinpath(repo_directory,"notebook",folder)
        isdir(dir) || mkpath(dir)

        ext = ".ipynb"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing

        args[:doctype] = "notebook"
        Weave.convert_doc(tmp,outfile)
    end

    if :pluto ∈ build_list
        println("Building Pluto notebook")
        dir = joinpath(repo_directory,"pluto",folder)
        isdir(dir) || mkpath(dir)


        ext = ".jl"
        outfile = joinpath(dir, bnm*ext)
        build_file(file, outfile, force=force) || return nothing

        md2jl(file, outfile)
    end

end

"""
    weave_all(; force=false, build_list=(:script,:html,:pdf,:github,:notebook))

Run `weave` on all source files.

* `force`: by default, only run `weave` on files with `html` file older than the source file in `CwJ`
* `build_list`: list of output types to be built. The default is all types

The files will be built as subdirectories in the package directory. This is returned by `pathof(CalculusWithJulia)`.

"""
function weave_all(;force=false, build_list=(:script,:html,:pdf,:github,:notebook))
    folders = readdir(joinpath(repo_directory,"CwJ"))
    folders = filter(F -> isdir(joinpath(repo_directory, "CwJ", F)), folders)
    asyncmap(F -> weave_folder(F; force=force, build_list=build_list), folders)
#    for folder in readdir(joinpath(repo_directory,"CwJ"))
#        folder == "test.jmd" && continue
#        weave_folder(folder; force=force, build_list=build_list)
#    end
end

function weave_folder(folder; force=false, build_list=(:html,))
    !isnothing(match(r"\.ico$", folder)) && return nothing
    files = readdir(joinpath(repo_directory,"CwJ",folder))
    files = filter(f -> occursin(r".jmd$", basename(f)), files)
    asyncmap(file -> weave_file(folder, file; force=force, build_list=build_list), files)
    # for file in readdir(joinpath(repo_directory,"CwJ",folder))
    #     !occursin(r".jmd$", basename(file)) && continue
    #     println("Building $(joinpath(folder,file))")
    #     try
    #         weave_file(folder,file; force=force, build_list=build_list)
    #     catch
    #     end
    # end
end