require "ctx_config" -- pripoji subor 
require "ctx_typography"

function Write_to(file,str)
	if str~=nil then
  		file:write(str)
  	end
end -- writes string to the file

function New_stack()
	return {""}   -- starts with an empty string
end
function Init(file_name)
  ctx_line=1
  
  if context_mode then
    ctx_char_number=-5
  else
    ctx_char_number=-3
  end

  is_over = false
  braces_reading=0
  buffer = New_stack()

  file  = assert(io.open(file_name, "r","nepodarilo sa najst subor vstupu"))
  file2 = assert(io.open([[ctx_checked_]]..file_name,"w"))

  io.input(file)
end    
    
function Add_string (stack, s)
	if s~=nil and stack~=nil then
		table.insert(stack, s)    -- push 's' into the the stack  
	end
end

function Concat_buffer(stack)
	if stack~=nil then
		concatenated_word=table.concat(stack)
		return concatenated_word
	end	
end

function Number_in_set(t,val)
    for k,v in pairs(t) do 
        if v == val then return k end
    end
end   

function Change_setting(char,array,number)
  str=char
  char=Read_char(1)
  if char~=nil then  
    str=str..char
  end  
  if char=="+" then
    array[number]=true
  elseif char=="-" then
    array[number]=false
  end
  return str
end

function Read_char(amount)
	local next_char=io.read(amount)
	if next_char=="\n" then
			ctx_line=ctx_line+1
			ctx_char_number=-1
	end

	if is_over==false then
		ctx_char_number=ctx_char_number+1
    if next_char~=nil then
      if next_char:byte()==195 or next_char:byte()==196 or next_char:byte()==197 or next_char=="" then
        ctx_char_number=ctx_char_number-1
      elseif next_char:byte()==226 then
        ctx_char_number=ctx_char_number-2
      end
    end
		if braces_reading>0 then
			if next_char~=nil then
				if next_char=="{" then closing_braces=closing_braces+1 end
				if next_char=="}" then closing_braces=closing_braces-1 end
				if closing_braces==0 then is_over=true	end
				return (next_char)
			else 
				is_over=true
			end
		elseif next_char~=nil then
				return (next_char)
		else 
				is_over=true
		end
	end
			
end -- nacita znak a skontroluje ci nie je prazdny

function Read_keyword()
	local next_char=Read_char(1)
	local key_word_buffer=New_stack()
	if next_char==[[%]] or next_char==[[,]] then
		ctx_char=next_char
		return next_char 
	end
  	while (string.byte(next_char)>96 and string.byte(next_char)<123) or (string.byte(next_char)>64 and string.byte(next_char)<91) 
    --or (string.byte(next_char)>47 and string.byte(next_char)<58) --klucove slovo neobsahuje cisla
    do
  		Add_string(key_word_buffer,next_char)
  		next_char=Read_char(1)
	end
	key_word=Concat_buffer(key_word_buffer)
	Write_to(file2,key_word)
	ctx_char=next_char
	return key_word
end -- nacita klucove slovo


function Fill (list)
	local set = {}
	for _, l in ipairs(list) do 
		set[l] = true
	end
	return set
end -- naplnenie poli

function Union(t1,t2)
    for i=1,#t2 do
        t1[#t1+1] = t2[i]
    end
    return t1
end -- spoji dve tabulky

function Read_spaces() 
  if ctx_char~=nil and ctx_char~="" then
    while ctx_char==" " or  ctx_char:byte()==9 or ctx_char=="~" do
      Write_to(file2,ctx_char)
      ctx_char=Read_char(1) 
      if ctx_char==nil or ctx_char =="" then 
        break 
      end
    end
  end  
end	-- cita znaky az kym nenajde znak rôzny od medzery

function Read_brackets(max_brackets)
	local current_brackets=0
  local next_line=0
	while current_brackets<max_brackets and next_line<2 do
		Read_spaces()     
		if ctx_char=="[" then
      next_line=0
			current_brackets=current_brackets+1 
      Finish_brackets()
		elseif ctx_char=="%" then
      Read_comment()
    elseif ctx_char=="\n" then
      Write_to(file2,ctx_char)
      next_line=next_line+1 
	  else
      break											  
    end  
    ctx_char=Read_char(1)
	end
end -- precita dany pocet hranatych zatvoriek

function Read_bracesB(max_braces)
	local current_braces=0
  local next_line=0
	while next_line<2 and current_braces<max_braces do
		Read_spaces()  
		if ctx_char=="{" then 
			current_braces=current_braces+1 
			Finish_braces()
      next_line=0
    elseif ctx_char=="%" then 
	  	Read_comment()
    elseif ctx_char=="\n" then
      Write_to(file2,ctx_char)
      next_line=next_line+1     
	  else
	  	break											
    end
		ctx_char=Read_char(1)															
	end
end

function Read_parentheses(max_parentheses)
	local current_parentheses=0
  local next_line=0
	while current_parentheses<max_parentheses and next_line<2 do
		Read_spaces()
		if ctx_char=="(" then  
			current_parentheses=current_parentheses+1 
			Finish_parentheses()
      next_line=0
		elseif ctx_char=="%" then 
	   	Read_comment()
    elseif ctx_char=="\n" then
      next_line=next_line+1
      Write_to(file2,ctx_char)
    else
      break										
		end
		ctx_char=Read_char(1)															
	end
end

function Read_bracesA(max_braces)
  local current_braces=0
  local next_line=0
	while current_braces~=max_braces and not is_over and next_line<2 do
		Read_spaces()  
    if ctx_char=="{" then
      current_braces=current_braces+1
			Write_to(file2,ctx_char)
      braces_reading=braces_reading+1
      closing_braces=1
      Process_context()
      is_over=false
      braces_reading=braces_reading-1
      Write_to(file2,ctx_char)
      next_line=0
		elseif ctx_char=="%" then
			Read_comment()
    elseif ctx_char=="\n" then
      Write_to(file2,ctx_char)
      next_line=next_line+1   
		else
			break
		end
    ctx_char=Read_char(1)
	end
end  
function Finish_braces()
	Write_to(file2,ctx_char)
	local close_braces=1
	while ctx_char~="}" or close_braces~=0 do     
		ctx_char=Read_char(1)
   		if ctx_char=="{" then 
        close_braces=close_braces+1
        Write_to(file2,ctx_char)
   		elseif ctx_char=="}" then 
        close_braces=close_braces-1
        Write_to(file2,ctx_char)
      elseif ctx_char== "%" then 
        Read_comment()
      elseif ctx_char==nil then
        break
      else
        Write_to(file2,ctx_char)
      end  
   	end
end -- precita obsah zlozenych zatvoriek, ktory ale neformatuje

function Finish_brackets()
	local close_brackets=1
	local brackets_buffer=New_stack()
	Write_to(file2,ctx_char)
	while ctx_char~="]" or close_brackets~=0 do 
		ctx_char=Read_char(1)      --nacita obsah zlozenych zatvoriek 
   	if ctx_char==[["]] and brackets_equotation then
   		Write_to(file2,ctx_char)
   		ctx_char=Read_char(1)
   		start_char_number=ctx_char_number
   		start_line=ctx_line
   		while ctx_char~=[["]] do
   			Add_string(brackets_buffer,ctx_char) 
   			ctx_char=Read_char(1)
   		end
   		Write_to(file2,Concat_buffer(Ctx_detect_mistakes(ctx_settings,brackets_buffer,start_line,(start_char_number-1))))
      Write_to(file2,ctx_char)
    elseif ctx_char== "%" then 
   		Read_comment()		 	
    elseif ctx_char=="[" then
      Write_to(file2,ctx_char)
      close_brackets=close_brackets+1
   	elseif ctx_char=="]" then
      Write_to(file2,ctx_char)
   		close_brackets=close_brackets-1
    elseif ctx_char==nil then
        break  
    else
      Write_to(file2,ctx_char)
    end
  end
end -- precita obsah hranatej zatvorky



function Finish_parentheses()
	Write_to(file2,ctx_char)
	local close_parentheses=1
	while ctx_char~=")" or close_parentheses~=0 do      
		ctx_char=Read_char(1)
		if ctx_char== "%" then 
			Read_comment()
   	elseif ctx_char=="(" then 
   		close_parentheses=close_parentheses+1
      Write_to(file2,ctx_char)
    elseif ctx_char==")" then 
   		close_parentheses=close_parentheses-1 
      Write_to(file2,ctx_char)
    elseif ctx_char==nil then
      break
    else
      Write_to(file2,ctx_char)
    end
	end
end -- precita obsah ohruhlej zatvorky, ktory neformatuje

function Read_comment()
	Write_to(file2,ctx_char)
	ctx_char=Read_char(1)
	local mark=""
	if ctx_char=="@" then
    mark=mark..ctx_char
    ctx_char=Read_char(1)
    if ctx_char=="+" then 
      for i=1,#ctx_settings do
        ctx_settings[i]=true 
      end 
    elseif ctx_char=="-" then
      for i=1,#ctx_settings do 
        ctx_settings[i]=false 
      end
    end
    mark=mark..ctx_char
    Write_to(file2,mark)
  elseif ctx_char=="~" then
    mark=Change_setting(ctx_char,ctx_settings,1)  
		Write_to(file2,mark)
	elseif ctx_char=="." then
    mark=Change_setting(ctx_char,ctx_settings,2)  
		Write_to(file2,mark)
  elseif ctx_char=="," then
    mark=Change_setting(ctx_char,ctx_settings,3)  
		Write_to(file2,mark)
  elseif ctx_char=="!" then
    mark=Change_setting(ctx_char,ctx_settings,4)  
    Write_to(file2,mark)
  elseif ctx_char=="?" then
    mark=Change_setting(ctx_char,ctx_settings,5)  
		Write_to(file2,mark)
  elseif ctx_char==";" then
    mark=Change_setting(ctx_char,ctx_settings,6)  
		Write_to(file2,mark)
  elseif ctx_char=="-" then
    mark=Change_setting(ctx_char,ctx_settings,9)  
		Write_to(file2,mark)
  elseif ctx_char=="(" then
    mark=Change_setting(ctx_char,ctx_settings,8)  
		Write_to(file2,mark)
  elseif ctx_char=="*" then
    mark=Change_setting(ctx_char,ctx_settings,7)  
		Write_to(file2,mark)      
  elseif ctx_char==[[']] then
    mark=Change_setting(ctx_char,ctx_settings,10)  
		Write_to(file2,mark)      
  else
		local comment_line=io.read()
		if ctx_char ~= nil and comment_line~=nil then
      comment_line=ctx_char..comment_line
    end  
    
    if comment_line~=nil then
      local comment_buffer={}
      if check_comments then
        for i=1,#comment_line do 
          Add_string(comment_buffer,comment_line:sub(i,i))
        end
        Add_string(comment_buffer,"\n")
        Write_to(file2,Concat_buffer(Ctx_detect_mistakes(ctx_settings,comment_buffer,ctx_line,ctx_char_number)))
        ctx_line=ctx_line+1
        ctx_char_number=-1
      else
        Write_to(file2,comment_line.."\n")
        ctx_line=ctx_line+1
        ctx_char_number=-1
      end
    else
      Write_to(file2,"\n")
      ctx_line=ctx_line+1
      ctx_char_number=-1
    end 
	end	
end -- nacita komentar alebo zarazku


function Read_block(stop_string, enable_check)
  Write_to(file2,ctx_char)
  local stop_word=""
  while not enable_check do
    ctx_char=Read_char(1)
    if ctx_char==[[\]] then 
      Write_to(file2,ctx_char)
      stop_word=Read_keyword()
      if stop_word==stop_string then
        Write_to(file2,ctx_char)
        break
      else
        Write_to(file2,ctx_char)
      end
    elseif ctx_char=="%" then
      Read_comment()
    elseif ctx_char==nil then
			error([[Block was not finished correctly! \]]..end_string.." not found!")        
    else 
      Write_to(file2,ctx_char)
    end
  end
  ctx_char=Read_char(1)
end


function Find_starttext()
  if start_stop_text then
    ctx_char=Read_char(1)
    local is_starttext=false
	local start = ""
    while not is_starttext do
      if ctx_char==[[\]] then 
        Write_to(file2,ctx_char)
        start=Read_keyword()
        if start=="starttext" then
          break
        end
      elseif ctx_char==nil then
        Write_to(file2,ctx_char)
        break
      else
        Write_to(file2,ctx_char)
        ctx_char=Read_char(1)
      end
    end
    Write_to(file2,ctx_char)
  end
end


function Read_universal(val)
  local next_line=0
	while next_line<2 do
		Read_spaces()     
		if ctx_char=="[" then
      next_line=0   
      Finish_brackets()
    elseif ctx_char=="{" then
      next_line=0
      if not val then
        Finish_braces()
      else
      	Write_to(file2,ctx_char)
        braces_reading=braces_reading+1
        closing_braces=1
        Process_context()
        is_over=false
        braces_reading=braces_reading-1
        Write_to(file2,ctx_char)
      end
		elseif ctx_char=="%" then 
      Read_comment()
    elseif ctx_char=="\n" then
      Write_to(file2,ctx_char)
      next_line=next_line+1 
	  else
      break											  
    end  
    ctx_char=Read_char(1)
	end
end


one_bracesA=Union(one_bracesA,add_one_bracesA)
two_bracesA=Union(two_bracesA,add_two_bracesA)
three_bracesA=Union(three_bracesA,add_three_bracesA)
four_bracesA=Union(four_bracesA,add_four_bracesA)
no_parameters=Union(no_parameters,add_no_parameters)
brackets_bracesA=Union(brackets_bracesA,add_brackets_bracesA)
brackets_two_bracesA=Union(brackets_two_bracesA,add_brackets_two_bracesA)
two_brackets_bracesA=Union(two_brackets_bracesA,add_two_brackets_bracesA)
two_brackets_two_bracesA=Union(two_brackets_two_bracesA,add_two_brackets_two_bracesA)
parentheses=Union(parentheses,add_parentheses) 
block_begin=Union(block_begin,add_block_begin) 
block_end=Union(block_end,add_block_end)
two_bracesB=Union(two_bracesB,add_two_bracesB) 
file_name=Union(file_name,add_file_name) 
six_brackets=Union(six_brackets,add_six_brackets) 
five_brackets=Union(five_brackets,add_five_brackets) 
four_brackets=Union(four_brackets,add_four_brackets) 
three_brackets=Union(three_brackets,add_three_brackets) 
two_brackets=Union(two_brackets,add_two_brackets) 
one_brackets=Union(one_brackets,add_one_brackets) 
one_bracesB=Union(one_bracesB,add_one_bracesB)
three_bracesB=Union(three_bracesB,add_three_bracesB)
four_bracesB=Union(four_bracesB,add_four_bracesB)
two_bracesA_brackets=Union(two_bracesA_brackets,add_two_bracesA_brackets)
brackets_bracesA_brackets=Union(brackets_bracesA_brackets,add_brackets_bracesA_brackets)-- k stanovenym klucovym slovam tu v subore, prida pole z configu

local state   = Fill (one_bracesA)
local state2  = Fill (no_parameters)
local state3  = Fill (brackets_bracesA)
local state4  = Fill (parentheses_braces)
local state5  = Fill (block_begin)
local state6  = Fill (two_bracesB)
local state7  = Fill (three_bracesB)
local state8  = Fill (file_name)
local state9  = Fill (four_brackets)
local state10 = Fill (two_brackets)
local state11 = Fill (block_end)
local state12 = Fill (four_bracesB)
local state13 = Fill (one_brackets)
local state14 = Fill (three_brackets)
local state15 = Fill (four_bracesA)
local state16 = Fill (five_brackets)
local state17 = Fill (six_brackets)
local state18 = Fill (brackets_two_bracesA)
local state19 = Fill (two_brackets_bracesA)
local state20 = Fill (two_brackets_two_bracesA)
local state21 = Fill (two_bracesA_brackets)
local state22 = Fill (brackets_bracesA_brackets)
local state23 = Fill (universalA)
local state24 = Fill (universalB)
local state25 = Fill (one_bracesB)


function Process_context()
  ctx_char=Read_char(1)
	while not is_over do -- premenna is_over sa meni na true ked funkcia nacitaj najde koniec suboru (vrati prazdny ctx_char)
		if ctx_char==[[\]] then	
      Write_to(file2,ctx_char)
			ctx_keyword=Read_keyword()
			if state[ctx_keyword] then --nasleduje jedna zlozena zatvorka formatovana
				Read_bracesA(1)                  
																					
			elseif state3[ctx_keyword] then
        Read_brackets(1)
        Read_bracesA(1)
																						
			elseif state4[ctx_keyword] then --okruhle a zlozene (tie formatuje)
				Read_parentheses(1)
        Read_bracesA(1)    
																					
			elseif state5[ctx_keyword] then 
				block_number=Number_in_set(block_begin,ctx_keyword)
        Read_block(block_end[block_number],false)
				
      elseif ctx_keyword=="starttyping" then --starttyping, neformatuje (resp. je moznostou volby) az kym nenajde stoptyping
        Read_block("stoptyping",check_typing_block)
																					
			elseif state6[ctx_keyword] then --dvoje zlozene zatvorky ktore neformatuje
				Read_bracesB(2)				 
      
      elseif state7[ctx_keyword] then
        Read_bracesB(3)
      
			elseif state9[ctx_keyword] then -- nacita max 4 hranate zatvorky
				Read_brackets(4)
																						
			elseif state8[ctx_keyword] then 	-- za klucovym slovom sa nachadza retazec, ktory je ale nazvom suboru - takze neformatuje	
				Read_spaces()
				while ctx_char~=" " and ctx_char~=nil and ctx_char~="" and ctx_char~="\n" do
          Write_to(file2,ctx_char)
          ctx_char=Read_char(1)
          if ctx_char==nil or ctx_char=="" then
            break
          end  
        end
        Write_to(file2,ctx_char)
				ctx_char=Read_char(1)
				
			elseif state10[ctx_keyword] then
				Read_brackets(2)
				
			elseif state12[ctx_keyword] then
        Read_bracesB(4)
				
			elseif state13[ctx_keyword] then
				Read_brackets(1)
			
			elseif state14[ctx_keyword] then
				Read_brackets(3)
        
      elseif state15[ctx_keyword] then
        Read_bracesA(4)
      
      elseif state16[ctx_keyword] then
				Read_brackets(5)
        
      elseif state17[ctx_keyword] then
        Read_brackets(6)
      
      elseif state18[ctx_keyword] then
        Read_brackets(1)
        Read_bracesA(2)
        
			elseif state19[ctx_keyword] then
        Read_brackets(2)
        Read_bracesA(1)																		
			
      elseif state20[ctx_keyword] then
        Read_brackets(2)
        Read_bracesA(2)
        
      elseif state21[ctx_keyword] then
        Read_bracesA(2)	  
        Read_brackets(1)
      
      elseif state22[ctx_keyword] then
        Read_brackets(1)
        Read_bracesA(1)	  
        Read_brackets(1)
      
      elseif ctx_keyword==[[%]]  or ctx_keyword==[[,]] then 	-- v texte sa nachadza \% takze ho len zapise a nepovazuje za komentar
				Write_to(file2,ctx_char)
				ctx_char=Read_char(1)
        
      elseif state23[ctx_keyword] then
        Read_universal(true)
        
      elseif state24[ctx_keyword] then
        Read_universal(false)
        
      elseif state25[ctx_keyword] then
        Read_bracesB(1)
      
      elseif ctx_keyword=="stoptext" and start_stop_text then
        while ctx_char~=nil do
          Write_to(file2,ctx_char)
          ctx_char=Read_char(1)
          if ctx_char==nil then
            break
          end
        end  
     
      elseif state2[ctx_keyword] then -- bez parametrov
				--print("bol bez parametra")
     
			else -- nezname klucove slovo
				--print("klucove slovo "..ctx_keyword.." nepoznam")							
			end
					   		
		elseif ctx_char==[[%]] then -- na zaklade volby nacita a formatuje/neformatuje komentar
			Read_comment()
			ctx_char=Read_char(1)	
				
		else 
			Add_string(buffer,ctx_char)
			start_char_number=ctx_char_number
			start_line=ctx_line
			while ctx_char~=[[\]] and ctx_char~=nil and ctx_char~=[[%]] and not is_over	do --kym nenajde niektory z riadiacich znakov tak nacitava retazec
				ctx_char=Read_char(1)
				if ctx_char ~=[[\]] and ctx_char~=nil and ctx_char~=[[%]] and not is_over then
					Add_string(buffer,ctx_char)
				end
			end
      Write_to(file2,Concat_buffer(Ctx_detect_mistakes(ctx_settings,buffer,start_line,start_char_number))
        )
      buffer=New_stack()
		end								            
	end
end

function Create_recommendations()
  file4 = assert(io.open([[ctx_checked_]]..input_file,"r"))
  
  if context_mode then
    file3 = assert(io.open([[recommendations.tex]], "w"))
  else
    file3 = assert(io.open([[recommendations.txt]], "w"))
  end  

  io.output(file3)
  table.sort(ctx_mistakes,Compare)
  table.insert(ctx_mistakes,{99999,99999})

  local original_file_lines={}
  file:seek("set")
  Count_equotation_marks(file)
  file:seek("set")

  for original_line in file:lines() do
    table.insert(original_file_lines,original_line)
  end

  Write_to(file3,input_file.."\n")
  Write_to(file3,"------------------".."\n")

  if ctx_mistakes[1][1]==99999 and ctx_mistakes[1][2]==99999 then
    Write_to(file3,"No mistakes found.")
  else
    local l=1
  
    if context_mode then 
      correction=0
    else
      correction=1
    end 
    
    while ctx_mistakes[l][1]~=99999 and ctx_mistakes[l][2]~=99999 do
      Write_to(file3,"WARNING!")
      Write_to(file3," Line: "..ctx_mistakes[l][1].." ")
      Write_to(file3,"Character(s) number: ")
      mistakes={}
      repeat 
        table.insert(mistakes,{ctx_mistakes[l][1],ctx_mistakes[l][2],ctx_mistakes[l][3]})
        l=l+1
      until ctx_mistakes[l-1][1]~=ctx_mistakes[l][1] or ctx_mistakes[l][1]==9999
    
      table.sort(mistakes,Compare2)
    
      for i=1,#mistakes do
        if mistake_description then
          Write_to(file3,(mistakes[i][2]-correction).." - "..mistakes[i][3].."  ")
        else
          Write_to(file3,(mistakes[i][2]-correction).."  ")
        end    
      end
      Write_to(file3,"\n")  

      old_start=ctx_mistakes[l-1][1]-lines_to_output    
      old_stop=ctx_mistakes[l-1][1]+lines_to_output
    
      if old_start<1 then 
        old_start = 1 
      end
      
      if old_stop>#original_file_lines then 
        old_stop=#original_file_lines 
      end  
      
      for j=old_start,old_stop do
        Write_to(file3,"OLD "..j..". "..original_file_lines[j].."\n") 
      end
		
      count=1
      file4:seek("set")
      for new_line in file4:lines() do
        if count==ctx_mistakes[l-1][1] then
          Write_to(file3,"NEW "..new_line.."\n")
        end	
        count=count+1
      end
      Write_to(file3,"----------------------------------------------------------".."\n")
    end										
  end			
  file:close()
  file3:close()
  file4:close()
end

function Main()
  local dont_run=false
  if arg[1]~=nil then
    Init(arg[1])
    input_file=arg[1]
  elseif input_file~="" and input_file~=nil then
    Init(input_file)
  else
    --error("No input file chosen, set it in ctx_config or as parameter in command line",0)
    print("No input file chosen, set it in ctx_config or as parameter in command line")
    dont_run=true
  end
  if not dont_run then
    if context_mode then
      Find_starttext()
      Process_context()
    else
      txt_buffer={}
      char=file:read(1)
      while char~=nil do
        Add_string(txt_buffer,char)
        char=file:read(1)
      end
      Write_to(file2,Concat_buffer(Ctx_detect_mistakes(ctx_settings, txt_buffer, 1, 0)))
    end
    
    file2:close()
    
    Create_recommendations()
    
    if (#ctx_mistakes-1)==1 then
      return ("Done, found "..(#ctx_mistakes-1).." mistake")
    elseif (#ctx_mistakes-1)==0 then
      return ("No mistakes found! Well done")
    else
      return ("Done, found "..(#ctx_mistakes-1).." mistakes")
    end
  end
end 

print(Main())