from html5tagger import Document, E, HTML
import shutil
import markdown
import html
from pathlib import Path

def parseLink(link, pagetitle, homepage):
  if link.strip() == pagetitle + ".page":
    return "#"
  elif link.strip() == homepage + ".page":
    return "/"
  else:
    destination = link.replace(" ", "-").replace(".page", "").lower()

    #Start local links with / symbol
    if link.strip().endswith(".page"):
      return "/" + destination
    return destination

def generateNavigationBar(lines, pagetitle):
  global navbar
  navbar = E
  rawhtml = False
  htmlstring = ""
  dropdown = False
  for id, line in enumerate(lines):

    #parse raw HTML
    rawhtml, navbar, htmlstring = parseRawHTML(navbar, line, htmlstring, rawhtml, id, len(lines))

    #parse navigation bar (custom format)
    if not rawhtml:
      if "::" in line:
        title, link = line.split("::", 1)

        if line.strip().endswith("|"):
          dropdown = True
          link = link.strip()[:len(link.strip())-1]
          dphtml = E

          #some duplicate logic as normal navbar entries get, to make dropdown button in itself act like a normal clickable navbar entry
          link = parseLink(link, pagetitle, homepage)
          if link.strip() == "#":
            dphtml = dphtml(HTML("<div class='dropdown'><div class='dropbutton'><div class='active'><a href='" + link.strip() + "'>" + title + "</a></div></div><div class='dropdown-content'>"))
          elif link.strip() == "":
            dphtml = dphtml(HTML("<div class='dropdown'><div class='dropbutton'><a>" + title + "</a></div><div class='dropdown-content'>"))
          else:
            dphtml = dphtml(HTML("<div class='dropdown'><div class='dropbutton'><a href='" + link.strip() + "'>" + title + "</a></div><div class='dropdown-content'>"))
          continue

        elif dropdown:
          if line.startswith("  "):

            link = parseLink(link, pagetitle, homepage)
            if link.strip() == "#":
              dphtml = dphtml(HTML("<div class='active'><a href='" + link.strip() + "'>" + title + "</a></div>"))
            else:
              dphtml = dphtml(HTML("<a href='" + link.strip() + "'>" + title + "</a>"))

            #handle end of indentation (if indented line is the last line of page or next line is not indented)
            if len(lines) - id == 1 or lines[id + 1].startswith("  ") is False:
              dphtml = dphtml(HTML("</div></div>"))
              navbar = navbar.li(dphtml)
              dropdown = False
            continue

		#mark currently open tab as active when it is open
        link = parseLink(link, pagetitle, homepage)
        if link.strip() == "#":
          navbar = navbar.li(HTML("<div class='active'>" + "<a href='" + link.strip() + "'>" + title + "</a></div>"))
          continue

        navbar = navbar.li(HTML("<a href='" + link.strip() + "'>" + title + "</a>"))
      else:
        print("Error: invalid navbar entry, line " + str(id + 1) + " content: " + line)
        exit()
  return navbar

def generateFooter(lines):
  global footer
  footer = E
  rawhtml = False
  htmlstring = ""
  for id, line in enumerate(lines):

    #parse raw HTML
    rawhtml, footer, htmlstring = parseRawHTML(footer, line, htmlstring, rawhtml, id, len(lines))

    #parse markdown
    if not rawhtml:
      footer = footer.li(HTML(parseMarkdown(line)))

def parseRawHTML(doc, line, htmlstring, rawhtml, id, maxlines):

  #raw html start
  if line.strip() == ">":
    rawhtml = True
    htmlstring = ""

  #parse indented raw html
  elif rawhtml:
    # 2 spaces or tab
    if line.startswith("  ") or line.startswith("	"):

      htmlstring = htmlstring + line.strip()

      #if indented html was the last line, this is needed for it to not be ignored
      #since this is the end of the file, we will not set rawhtml to False.
      if maxlines - id == 1:
        doc = doc(HTML(htmlstring))
    else:
      rawhtml = False
      doc = doc(HTML(htmlstring))
      htmlstring = ""

  return rawhtml, doc, htmlstring

def parseMarkdown(line):

  #do not allow HTML in markdown
  line = html.escape(line.strip())
  return markdown.markdown(line)

def generateLines(title, lines, path):
  title = title.replace(".page", "")
  doc = Document(title, lang="en")
  rawhtml = False
  htmlstring = ""
  for id, line in enumerate(lines):

    #parse raw HTML
    rawhtml, doc, htmlstring = parseRawHTML(doc, line, htmlstring, rawhtml, id, len(lines))

    #parse markdown
    if not rawhtml:
      doc = doc(HTML(parseMarkdown(line)))

  generatePage(title, doc, path)

def generatePage(title, doc, path):
  global pages
  global titles
  global paths
  if 'pages' not in globals():
    pages = []
  if 'titles' not in globals():
    titles = []
  if 'paths' not in globals():
    paths = []

  navbarfile = Path("./").parent.joinpath('navbar')

  if navbarfile.exists():
    with navbarfile.open('r') as navbarfile:
      navbar = generateNavigationBar(navbarfile.readlines(), title)

    if 'footer' in globals():
      pages.append(str(E.ul(navbar)) + "<div class='content'>" + str(doc) + "</div>" + str(E.ul(footer)))
    else:
      pages.append(str(E.ul(navbar)) + "<div class='content'>" + str(doc) + "</div>")
  else:
    print("No 'navbar' file found, there will be no navigation bar.")

    if 'footer' in globals():
      pages.append("<div class='content'>" + str(doc) + "</div>" + str(E.ul(footer)))
    else:
      pages.append("<div class='content'>" + str(doc) + "</div>")

  titles.append(title)
  paths.append(path)

def writePages():
  global pages
  global titles
  global paths
  if 'pages' not in globals():
    print("Error: no page files found")
    exit()
    #TODO only delete files that aren't present in newest site generation
    #deleting contents of folder without deleting the folder, to increase compatibility with various systems
    #for root, dirs, files in os.walk('./website-output'):
    #  for f in files:
    #    os.unlink(os.path.join(root, f))
    #  for d in dirs:
    #    rmtree(os.path.join(root, d))

  for id, page in enumerate(pages):
    foldername = ""

    #creates ./website-output/pagetitle/index.html file if it is not homepage
    if titles[id] != homepage:
      foldername = titles[id].replace(" ", "-").lower()

    outputpath = Path("./").parent.joinpath("website-output")
    pageoutput = outputpath.joinpath(paths[id])

    dirpath = pageoutput.joinpath(foldername)

    dirpath.mkdir(parents=True, exist_ok=True)

    filepath = dirpath.joinpath("index.html")

    if filepath.exists():
      with filepath.open('r') as newpage:
        if newpage.read() == page:
          print("Page not changed: " + titles[id])
          continue

    with filepath.open('w') as newpage:
      newpage.write(page)
      print("Written changed page: " + titles[id])

  #resources
  respath = Path("./").parent.joinpath("resources")
  if respath.exists():

    #shutil.copytree copies timestamp too
    shutil.copytree(respath, outputpath, dirs_exist_ok=True)

    #check if folders are named correctly
    for folder in outputpath.iterdir():
      if folder.is_dir():

        #rename folder name format from "About Page" to "about-page"
        bettername = folder.name.replace(" ", "-").lower()

        if folder.name != bettername:
          newpath = outputpath.joinpath(bettername)

          #example: resources folder is "About", page got auto-created earlier as "about" (from About.page), let's copy "About" resources to "about" and delete "About"
          if newpath.exists():
            shutil.copytree(folder, newpath, dirs_exist_ok=True)
            shutil.rmtree(folder)
          else:
            shutil.move(str(folder), newpath)
def findPages(dir):
  for file in dir.iterdir():
    if file.is_file():
      if file.suffix == ".page":
        with file.open('r') as page:
          generateLines(file.stem, page.readlines(), dir)
    elif file.stem != "resources" and file.stem != "website-output":
        findPages(file)

def main():

  #if homepage is at Home.page, set homepage to "Home"
  global homepage
  homepage = "Home"

  footerfile = Path("./").parent.joinpath('footer')

  if footerfile.exists():
    with footerfile.open('r') as footerfile:
      generateFooter(footerfile.readlines())
  else:
    print("No 'footer' file found, there will be no footer.")

  findPages(Path("./").parent)

  #write all pages to files
  writePages()

if __name__ == "__main__":
  main()