(* HCoop Domtool (http://hcoop.sourceforge.net/)
 * Copyright (c) 2006, Adam Chlipala
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *)

(* Domain-related primitive actions *)

structure Domain :> DOMAIN = struct

fun isIdent ch = Char.isLower ch orelse Char.isDigit ch

fun validHost s =
    size s > 0 andalso size s < 20
    andalso CharVector.all (fn ch => isIdent ch orelse ch = #"-") s

fun validDomain s =
    size s > 0 andalso size s < 100
    andalso List.all validHost (String.fields (fn ch => ch = #".") s)

val _ = Env.type_one "host"
	Env.string
	validHost

val _ = Env.type_one "domain"
	Env.string
	validDomain

open Ast

val befores = ref (fn (_ : string) => ())
val afters = ref (fn (_ : string) => ())

fun registerBefore f =
    let
	val old = !befores
    in
	befores := (fn x => (old x; f x))
    end

fun registerAfter f =
    let
	val old = !afters
    in
	afters := (fn x => (old x; f x))
    end

val current = ref ""
val currentPath = ref ""

val scratch = ref ""

fun currentDomain () = !current

fun domainFile name = TextIO.openOut (!currentPath ^ name)

fun getPath domain =
    let
	val toks = String.fields (fn ch => ch = #".") domain

	val elems = foldr (fn (piece, elems) =>
			      let
				  val elems = piece :: elems
				  val path = String.concatWith "/" (Config.resultRoot :: rev elems)
				  val tmpPath = String.concatWith "/" (Config.tmpDir :: rev elems)
			      in
				  (if Posix.FileSys.ST.isDir
					  (Posix.FileSys.stat path) then
				       ()
				   else
				       (OS.FileSys.remove path;
					OS.FileSys.mkDir path))
				  handle OS.SysErr _ => OS.FileSys.mkDir path;

				  (if Posix.FileSys.ST.isDir
					  (Posix.FileSys.stat tmpPath) then
				       ()
				   else
				       (OS.FileSys.remove tmpPath;
					OS.FileSys.mkDir tmpPath))
				  handle OS.SysErr _ => OS.FileSys.mkDir tmpPath;

				  elems
			      end) [] toks
    in
	fn root => String.concatWith "/" (root :: rev ("" :: elems))
    end

datatype file_action' =
	 Add' of {src : string, dst : string}
       | Delete' of string
       | Modify' of {src : string, dst : string}

fun findDiffs dom =
    let
	val realPath = getPath dom Config.resultRoot
	val tmpPath = !currentPath

	val dir = Posix.FileSys.opendir realPath

	fun loopReal acts =
	    case Posix.FileSys.readdir dir of
		NONE => (Posix.FileSys.closedir dir;
			 acts)
	      | SOME fname =>
		let
		    val real = OS.Path.joinDirFile {dir = realPath,
						    file = fname}
		    val tmp = OS.Path.joinDirFile {dir = tmpPath,
						   file = fname}
		in
		    if Posix.FileSys.ST.isDir (Posix.FileSys.stat real) then
			loopReal acts
		    else if Posix.FileSys.access (tmp, []) then
			if Slave.shell [Config.diff, " ", real, " ",  tmp] then
			    loopReal acts
			else
			    loopReal (Modify' {src = tmp, dst = real} :: acts)
		    else
			loopReal (Delete' real :: acts)
		end

	val acts = loopReal []

	val dir = Posix.FileSys.opendir tmpPath

	fun loopTmp acts =
	    case Posix.FileSys.readdir dir of
		NONE => (Posix.FileSys.closedir dir;
			 acts)
	      | SOME fname =>
		let
		    val real = OS.Path.joinDirFile {dir = realPath,
						    file = fname}
		    val tmp = OS.Path.joinDirFile {dir = tmpPath,
						   file = fname}
		in
		    if Posix.FileSys.ST.isDir (Posix.FileSys.stat tmp) then
			loopTmp acts
		    else if Posix.FileSys.access (real, []) then
			loopTmp acts
		    else
			loopTmp (Add' {src = tmp, dst = real} :: acts)
		end

	val acts = loopTmp acts
    in
	acts
    end

val _ = Env.container_one "domain"
			  ("domain", Env.string)
			  (fn dom =>
			      let
				  val path = getPath dom Config.tmpDir
			      in
				  current := dom;
				  currentPath := path;
				  !befores dom
			      end,
			   fn () =>
			      let
				  val dom = !current
				  val () = !afters dom

				  val diffs = findDiffs dom

				  val diffs = map (fn Add' {src, dst} =>
						      (Slave.shellF ([Config.cp, " ", src, " ", dst],
							      fn cl => "Copy failed: " ^ cl);
						       {action = Slave.Add,
							domain = dom,
							file = dst})
						    | Delete' dst =>
						      (OS.FileSys.remove dst
						       handle OS.SysErr _ =>
							      ErrorMsg.error NONE ("Delete failed for " ^ dst);
						       {action = Slave.Delete,
							domain = dom,
							file = dst})
						    | Modify' {src, dst} =>
						      (Slave.shellF ([Config.cp, " ", src, " ", dst],
							   fn cl => "Copy failed: " ^ cl);
						       {action = Slave.Modify,
							domain = dom,
							file = dst})) diffs
			      in
				  if !ErrorMsg.anyErrors then
				      ()
				  else
				      Slave.handleChanges diffs;
				  ignore (Slave.shellF ([Config.rm, " -rf ", Config.tmpDir, "/*"],
						  fn cl => "Temp file cleanup failed: " ^ cl))
			      end)

end