local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local assert = _tl_compat and _tl_compat.assert or assert; local io = _tl_compat and _tl_compat.io or io; local ipairs = _tl_compat and _tl_compat.ipairs or ipairs; local math = _tl_compat and _tl_compat.math or math; local pairs = _tl_compat and _tl_compat.pairs or pairs; local pcall = _tl_compat and _tl_compat.pcall or pcall; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table









local patch = { Lineends = {}, Hunk = {}, File = {}, Files = {} }































local fs = require("luarocks.fs")






local function open(filename, mode)
   return assert(io.open(fs.absolute_name(filename), mode))
end


local debugmode = false
local function dbg(_) end
local function info(_) end
local function warning(s) io.stderr:write(s .. '\n') end


local function startswith(s, s2)
   return s:sub(1, #s2) == s2
end


local function endswith(s, s2)
   return #s >= #s2 and s:sub(#s - #s2 + 1) == s2
end


local function endlstrip(s)
   return s:gsub('[\r\n]+$', '')
end


local function table_copy(t)
   local t2 = {}
   for k, v in pairs(t) do t2[k] = v end
   return t2
end

local function string_as_file(s)
   return {
      at = 0,
      str = s,
      len = #s,
      eof = false,
      read = function(self, n)
         if self.eof then return nil end
         local chunk = self.str:sub(self.at, self.at + n - 1)
         self.at = self.at + n
         if self.at > self.len then
            self.eof = true
         end
         return chunk
      end,
      close = function(self)
         self.eof = true
      end,
   }
end










local function file_lines(f)
   local CHUNK_SIZE = 1024
   local buffer = ""
   local pos_beg = 1
   return function()
      local pos, chars
      while 1 do
         pos, chars = buffer:match('()([\r\n].)', pos_beg)
         if pos or not f then
            break
         elseif f then
            local chunk = f:read(CHUNK_SIZE)
            if chunk then
               buffer = buffer:sub(pos_beg) .. chunk
               pos_beg = 1
            else
               f = nil
            end
         end
      end
      if not pos then
         pos = #buffer
      elseif chars == '\r\n' then
         pos = pos + 1
      end
      local line = buffer:sub(pos_beg, pos)
      pos_beg = pos + 1
      if #line > 0 then
         return line
      end
   end
end

local function match_linerange(line)
   local m1, m2, m3, m4 = line:match("^@@ %-(%d+),(%d+) %+(%d+),(%d+)")
   if not m1 then m1, m3, m4 = line:match("^@@ %-(%d+) %+(%d+),(%d+)") end
   if not m1 then m1, m2, m3 = line:match("^@@ %-(%d+),(%d+) %+(%d+)") end
   if not m1 then m1, m3 = line:match("^@@ %-(%d+) %+(%d+)") end
   return m1, m2, m3, m4
end

local function match_epoch(str)
   return str:match("[^0-9]1969[^0-9]") or str:match("[^0-9]1970[^0-9]")
end

function patch.read_patch(filename, data)

   local state = 'header'






   local all_ok = true
   local lineends = { lf = 0, crlf = 0, cr = 0 }
   local files = { source = {}, target = {}, epoch = {}, hunks = {}, fileends = {}, hunkends = {} }
   local nextfileno = 0
   local nexthunkno = 0



   local hunkinfo = {
      startsrc = nil, linessrc = nil, starttgt = nil, linestgt = nil,
      invalid = false, text = {},
   }
   local hunkactual = { linessrc = nil, linestgt = nil }

   info(string.format("reading patch %s", filename))

   local fp
   if data then
      fp = string_as_file(data)
   else
      fp = filename == '-' and io.stdin or open(filename, "rb")
   end
   local lineno = 0

   for line in file_lines(fp) do
      local line = line
      lineno = lineno + 1
      if state == 'header' then
         if startswith(line, "--- ") then
            state = 'filenames'
         end

      end
      if state == 'hunkbody' then


         if line:match("^[\r\n]*$") then

            line = " " .. line
         end


         if line:match("^[- +\\]") then

            local he = files.hunkends[nextfileno]
            if endswith(line, "\r\n") then
               he.crlf = he.crlf + 1
            elseif endswith(line, "\n") then
               he.lf = he.lf + 1
            elseif endswith(line, "\r") then
               he.cr = he.cr + 1
            end
            if startswith(line, "-") then
               hunkactual.linessrc = hunkactual.linessrc + 1
            elseif startswith(line, "+") then
               hunkactual.linestgt = hunkactual.linestgt + 1
            elseif startswith(line, "\\") then

            else
               hunkactual.linessrc = hunkactual.linessrc + 1
               hunkactual.linestgt = hunkactual.linestgt + 1
            end
            table.insert(hunkinfo.text, line)

         else
            warning(string.format("invalid hunk no.%d at %d for target file %s",
            nexthunkno, lineno, files.target[nextfileno]))

            table.insert(files.hunks[nextfileno], table_copy(hunkinfo))
            files.hunks[nextfileno][nexthunkno].invalid = true
            all_ok = false
            state = 'hunkskip'
         end


         if hunkactual.linessrc > hunkinfo.linessrc or
            hunkactual.linestgt > hunkinfo.linestgt then

            warning(string.format("extra hunk no.%d lines at %d for target %s",
            nexthunkno, lineno, files.target[nextfileno]))

            table.insert(files.hunks[nextfileno], table_copy(hunkinfo))
            files.hunks[nextfileno][nexthunkno].invalid = true
            state = 'hunkskip'
         elseif hunkinfo.linessrc == hunkactual.linessrc and
            hunkinfo.linestgt == hunkactual.linestgt then

            table.insert(files.hunks[nextfileno], table_copy(hunkinfo))
            state = 'hunkskip'


            local ends = files.hunkends[nextfileno]
            if (ends.cr ~= 0 and 1 or 0) + (ends.crlf ~= 0 and 1 or 0) +
               (ends.lf ~= 0 and 1 or 0) > 1 then

               warning(string.format("inconsistent line ends in patch hunks for %s",
               files.source[nextfileno]))
            end
         end

      end

      if state == 'hunkskip' then
         if match_linerange(line) then
            state = 'hunkhead'
         elseif startswith(line, "--- ") then
            state = 'filenames'
            if debugmode and #files.source > 0 then
               dbg(string.format("- %2d hunks for %s", #files.hunks[nextfileno],
               files.source[nextfileno]))
            end
         end

      end
      local advance
      if state == 'filenames' then
         if startswith(line, "--- ") then
            if files.source[nextfileno] then
               all_ok = false
               warning(string.format("skipping invalid patch for %s",
               files.source[nextfileno + 1]))
               table.remove(files.source, nextfileno + 1)


            end



            local match, rest = line:match("^%-%-%- ([^ \t\r\n]+)(.*)")
            if not match then
               all_ok = false
               warning(string.format("skipping invalid filename at line %d", lineno + 1))
               state = 'header'
            else
               if match_epoch(rest) then
                  files.epoch[nextfileno + 1] = true
               end
               table.insert(files.source, match)
            end
         elseif not startswith(line, "+++ ") then
            if files.source[nextfileno] then
               all_ok = false
               warning(string.format("skipping invalid patch with no target for %s",
               files.source[nextfileno + 1]))
               table.remove(files.source, nextfileno + 1)
            else

               warning("skipping invalid target patch")
            end
            state = 'header'
         else
            if files.target[nextfileno] then
               all_ok = false
               warning(string.format("skipping invalid patch - double target at line %d",
               lineno + 1))
               table.remove(files.source, nextfileno + 1)
               table.remove(files.target, nextfileno + 1)
               nextfileno = nextfileno - 1


               state = 'header'
            else



               local re_filename = "^%+%+%+ ([^ \t\r\n]+)(.*)$"
               local match, rest = line:match(re_filename)
               if not match then
                  all_ok = false
                  warning(string.format(
                  "skipping invalid patch - no target filename at line %d",
                  lineno + 1))
                  state = 'header'
               else
                  table.insert(files.target, match)
                  nextfileno = nextfileno + 1
                  if match_epoch(rest) then
                     files.epoch[nextfileno] = true
                  end
                  nexthunkno = 0
                  table.insert(files.hunks, {})
                  table.insert(files.hunkends, table_copy(lineends))
                  table.insert(files.fileends, table_copy(lineends))
                  state = 'hunkhead'
                  advance = true
               end
            end
         end

      end
      if not advance and state == 'hunkhead' then
         local m1, m2, m3, m4 = match_linerange(line)
         if not m1 then
            if not files.hunks[nextfileno - 1] then
               all_ok = false
               warning(string.format("skipping invalid patch with no hunks for file %s",
               files.target[nextfileno]))
            end
            state = 'header'
         else
            hunkinfo.startsrc = math.tointeger(m1)
            hunkinfo.linessrc = math.tointeger(m2) or 1
            hunkinfo.starttgt = math.tointeger(m3)
            hunkinfo.linestgt = math.tointeger(m4) or 1
            hunkinfo.invalid = false
            hunkinfo.text = {}

            hunkactual.linessrc = 0
            hunkactual.linestgt = 0

            state = 'hunkbody'
            nexthunkno = nexthunkno + 1
         end

      end
   end
   if state ~= 'hunkskip' then
      warning(string.format("patch file incomplete - %s", filename))
      all_ok = false
   else

      if debugmode and #files.source > 0 then
         dbg(string.format("- %2d hunks for %s", #files.hunks[nextfileno],
         files.source[nextfileno]))
      end
   end

   local sum = 0; for _, hset in ipairs(files.hunks) do sum = sum + #hset end
   info(string.format("total files: %d  total hunks: %d", #files.source, sum))
   fp:close()
   return files, all_ok
end

local function find_hunk(file, h, hno)
   for fuzz = 0, 2 do
      local lineno = h.startsrc
      for i = 0, #file do
         local found = true
         local location = lineno
         for l, hline in ipairs(h.text) do
            if l > fuzz then

               if startswith(hline, " ") or startswith(hline, "-") then
                  local line = file[lineno]
                  lineno = lineno + 1
                  if not line or #line == 0 then
                     found = false
                     break
                  end
                  if endlstrip(line) ~= endlstrip(hline:sub(2)) then
                     found = false
                     break
                  end
               end
            end
         end
         if found then
            local offset = location - h.startsrc - fuzz
            if offset ~= 0 then
               warning(string.format("Hunk %d found at offset %d%s...", hno, offset, fuzz == 0 and "" or string.format(" (fuzz %d)", fuzz)))
            end
            h.startsrc = location
            h.starttgt = h.starttgt + offset
            for _ = 1, fuzz do
               table.remove(h.text, 1)
               table.remove(h.text, #h.text)
            end
            return true
         end
         lineno = i
      end
   end
   return false
end

local function load_file(filename)
   local fp = open(filename)
   local file = {}
   local readline = file_lines(fp)
   while true do
      local line = readline()
      if not line then break end
      table.insert(file, line)
   end
   fp:close()
   return file
end

local function find_hunks(file, hunks)
   for hno, h in ipairs(hunks) do
      find_hunk(file, h, hno)
   end
end

local function check_patched(file, hunks)
   local lineno = 1
   local _, err = pcall(function()
      if #file == 0 then
         error('nomatch', 0)
      end
      for hno, h in ipairs(hunks) do

         if #file < h.starttgt then
            error('nomatch', 0)
         end
         lineno = h.starttgt
         for _, hline in ipairs(h.text) do

            if not startswith(hline, "-") and not startswith(hline, "\\") then
               local line = file[lineno]
               lineno = lineno + 1
               if #line == 0 then
                  error('nomatch', 0)
               end
               if endlstrip(line) ~= endlstrip(hline:sub(2)) then
                  warning(string.format("file is not patched - failed hunk: %d", hno))
                  error('nomatch', 0)
               end
            end
         end
      end
   end)

   return err ~= 'nomatch'
end

local function patch_hunks(srcname, tgtname, hunks)
   local src = open(srcname, "rb")
   local tgt = open(tgtname, "wb")

   local src_readline = file_lines(src)







   local srclineno = 1
   local lineends = { ['\n'] = 0, ['\r\n'] = 0, ['\r'] = 0 }
   for hno, h in ipairs(hunks) do
      dbg(string.format("processing hunk %d for file %s", hno, tgtname))

      while srclineno < h.startsrc do
         local line = src_readline()

         if endswith(line, "\r\n") then
            lineends["\r\n"] = lineends["\r\n"] + 1
         elseif endswith(line, "\n") then
            lineends["\n"] = lineends["\n"] + 1
         elseif endswith(line, "\r") then
            lineends["\r"] = lineends["\r"] + 1
         end
         tgt:write(line)
         srclineno = srclineno + 1
      end

      for _, hline in ipairs(h.text) do

         if startswith(hline, "-") or startswith(hline, "\\") then
            src_readline()
            srclineno = srclineno + 1
         else
            if not startswith(hline, "+") then
               src_readline()
               srclineno = srclineno + 1
            end
            local line2write = hline:sub(2)

            local sum = 0
            for _, v in pairs(lineends) do if v > 0 then sum = sum + 1 end end
            if sum == 1 then
               local newline
               for k, v in pairs(lineends) do if v ~= 0 then newline = k end end
               tgt:write(endlstrip(line2write) .. newline)
            else
               tgt:write(line2write)
            end
         end
      end
   end
   for line in src_readline do
      tgt:write(line)
   end
   tgt:close()
   src:close()
   return true
end

local function strip_dirs(filename, strip)
   if strip == nil then return filename end
   for _ = 1, strip do
      filename = filename:gsub("^[^/]*/", "")
   end
   return filename
end

local function write_new_file(filename, hunk)
   local fh = io.open(fs.absolute_name(filename), "wb")
   if not fh then return false end
   for _, hline in ipairs(hunk.text) do
      local c = hline:sub(1, 1)
      if c ~= "+" and c ~= "-" and c ~= " " then
         return false, "malformed patch"
      end
      fh:write(hline:sub(2))
   end
   fh:close()
   return true
end

local function patch_file(source, target, epoch, hunks, strip, create_delete)
   local create_file = false
   if create_delete then
      local is_src_epoch = epoch and #hunks == 1 and hunks[1].startsrc == 0 and hunks[1].linessrc == 0
      if is_src_epoch or source == "/dev/null" then
         info(string.format("will create %s", target))
         create_file = true
      end
   end
   if create_file then
      return write_new_file(fs.absolute_name(strip_dirs(target, strip)), hunks[1])
   end
   source = strip_dirs(source, strip)
   local f2patch = source
   if not fs.exists(f2patch) then
      f2patch = strip_dirs(target, strip)
      f2patch = fs.absolute_name(f2patch)
      if not fs.exists(f2patch) then
         warning(string.format("source/target file does not exist\n--- %s\n+++ %s",
         source, f2patch))
         return false
      end
   end
   if not fs.is_file(f2patch) then
      warning(string.format("not a file - %s", f2patch))
      return false
   end

   source = f2patch


   local file = load_file(source)
   local hunkno = 1
   local hunk = hunks[hunkno]
   local hunkfind = {}
   local validhunks = 0
   local canpatch = false
   local hunklineno
   if not file then
      return nil, "failed reading file " .. source
   end

   if create_delete then
      if epoch and #hunks == 1 and hunks[1].starttgt == 0 and hunks[1].linestgt == 0 then
         local ok = fs.delete(fs.absolute_name(source))
         if not ok then
            return false
         end
         info(string.format("successfully removed %s", source))
         return true
      end
   end

   find_hunks(file, hunks)

   local function process_line(line, lineno)
      if not hunk or lineno < hunk.startsrc then
         return false
      end
      if lineno == hunk.startsrc then
         hunkfind = {}
         for _, x in ipairs(hunk.text) do
            if x:sub(1, 1) == ' ' or x:sub(1, 1) == '-' then
               hunkfind[#hunkfind + 1] = endlstrip(x:sub(2))
            end
         end
         hunklineno = 1


      end

      if lineno < hunk.startsrc + #hunkfind - 1 then
         if endlstrip(line) == hunkfind[hunklineno] then
            hunklineno = hunklineno + 1
         else
            dbg(string.format("hunk no.%d doesn't match source file %s",
            hunkno, source))

            hunkno = hunkno + 1
            if hunkno <= #hunks then
               hunk = hunks[hunkno]
               return false
            else
               return true
            end
         end
      end

      if lineno == hunk.startsrc + #hunkfind - 1 then
         dbg(string.format("file %s hunk no.%d -- is ready to be patched",
         source, hunkno))
         hunkno = hunkno + 1
         validhunks = validhunks + 1
         if hunkno <= #hunks then
            hunk = hunks[hunkno]
         else
            if validhunks == #hunks then

               canpatch = true
               return true
            end
         end
      end
      return false
   end

   local done = false
   for lineno, line in ipairs(file) do
      done = process_line(line, lineno)
      if done then
         break
      end
   end
   if not done then
      if hunkno <= #hunks and not create_file then
         warning(string.format("premature end of source file %s at hunk %d",
         source, hunkno))
         return false
      end
   end
   if validhunks < #hunks then
      if check_patched(file, hunks) then
         warning(string.format("already patched  %s", source))
      elseif not create_file then
         warning(string.format("source file is different - %s", source))
         return false
      end
   end
   if not canpatch then
      return true
   end
   local backupname = source .. ".orig"
   if fs.exists(backupname) then
      warning(string.format("can't backup original file to %s - aborting",
      backupname))
      return false
   end
   local ok = fs.move(fs.absolute_name(source), fs.absolute_name(backupname))
   if not ok then
      warning(string.format("failed backing up %s when patching", source))
      return false
   end
   patch_hunks(backupname, source, hunks)
   info(string.format("successfully patched %s", source))
   fs.delete(fs.absolute_name(backupname))
   return true
end

function patch.apply_patch(the_patch, strip, create_delete)
   local all_ok = true
   local total = #the_patch.source
   for fileno, source in ipairs(the_patch.source) do
      local target = the_patch.target[fileno]
      local hunks = the_patch.hunks[fileno]
      local epoch = the_patch.epoch[fileno]
      info(string.format("processing %d/%d:\t %s", fileno, total, source))
      local ok = patch_file(source, target, epoch, hunks, strip, create_delete)
      all_ok = all_ok and ok
   end

   return all_ok
end

return patch