structure Converter =
struct
  fun loadIO (io, str) =
    case TextIO.inputLine io of
      SOME line => loadIO (io, str ^ line)
    | NONE => str

  fun convertFile fullPath =
    let
      val io = TextIO.openIn fullPath
      val text = loadIO (io, "")
      val () = TextIO.closeIn io
    in
      case Parser.parse text of
        SOME (canvasWidth, canvasHeight, tree) =>
          let
            val maxSide = Int.max (canvasWidth, canvasHeight)
            val squares = LayerTree.flatten (maxSide, tree)
            val exportString =
              CollisionTree.toExportString (squares, canvasWidth, canvasHeight, fullPath)

            val pathWithoutExtension = String.substring
              (fullPath, 0, String.size fullPath - 4)
            val outputFilePath = pathWithoutExtension ^ ".sml"
            val io = TextIO.openOut outputFilePath
            val () = TextIO.output (io, exportString)
          in
            TextIO.closeOut io
          end
      | NONE => (* we have an error, but ignore *) ()
    end

  fun endsWithDsc str =
    if String.size str >= 4 then
      let
        val size = String.size str
        val expectedExtension = String.substring (str, size - 4, 4)
      in
        expectedExtension = ".dsc"
      end
    else
      false

  fun loop (dir, rootPath) =
    case OS.FileSys.readDir dir of
      SOME path =>
        let
          val folderPath = String.concat [rootPath, "/", path]
          val () =
            if OS.FileSys.isDir folderPath then
              (* handle recursive directory *)
              let val newDir = OS.FileSys.openDir folderPath
              in loop (newDir, folderPath)
              end
            else if OS.FileSys.isLink folderPath then
              (* ignore *)
              ()
            else if endsWithDsc path then
              (* is a file ending with .dsc extension *)
              convertFile folderPath
            else
              (* is a file but doesn't end with .dsc, so ignore *)
              ()
        in
          loop (dir, rootPath)
        end
    | NONE => OS.FileSys.closeDir dir

  fun main () =
    let
      val path = OS.FileSys.getDir ()
      val dir = OS.FileSys.openDir path
    in
      loop (dir, path)
    end
end