#!/usr/bin/env ruby
# encoding: utf-8

#Nilac is the official Nila compiler. It compiles Nila into pure Javascript. Nilac is currently
#written in Ruby but will be self hosted in the upcoming years. Nila targets mostly the
#Node.js developers rather than client side developers.

#Nila was created by Adhithya Rajasekaran and Nilac is maintained by Adhithya Rajasekaran and Sri Madhavi Rajasekaran

require 'optparse'

def compile(input_file_path)

  def read_file_line_by_line(input_path)

    file_id = open(input_path)

    file_line_by_line = file_id.readlines()

    file_id.close

    return file_line_by_line

  end

  def extract_parsable_array(input_file_contents)

    #This method finds and removes the __END__ keyword and the following lines in a Nila file.

    modified_file_contents = input_file_contents.dup

    end_index = 0

    input_file_contents.each_with_index do |line,index|

      if line.strip.eql?("__END__")

        end_index = index

      end

    end

    if end_index == 0

      output = modified_file_contents

    else

      output = modified_file_contents[0..end_index-1]

      while output[-1].eql?("\n")

        output.delete_at(-1)

      end

    end

    return output

  end

  def replace_multiline_comments(input_file_contents,nila_file_path)

    #This method will replace both the single and multiline comments
    #
    #Single line comment will be replaced by => --single_line_comment[n]
    #
    #Multiline comment will be replaced by => --multiline_comment[n]

    def find_all_matching_indices(input_string,pattern)

      locations = []

      index = input_string.index(pattern)

      while index != nil

        locations << index

        index = input_string.index(pattern,index+1)


      end

      return locations


    end

    def find_file_path(input_path,file_extension)

      extension_remover = input_path.split(file_extension)

      remaining_string = extension_remover[0].reverse

      path_finder = remaining_string.index("/")

      remaining_string = remaining_string.reverse

      return remaining_string[0...remaining_string.length-path_finder]

    end

    def find_file_name(input_path,file_extension)

      extension_remover = input_path.split(file_extension)

      remaining_string = extension_remover[0].reverse

      path_finder = remaining_string.index("/")

      remaining_string = remaining_string.reverse

      return remaining_string[remaining_string.length-path_finder..-1]

    end

    multiline_comments = []

    file_contents_as_string = input_file_contents.join

    modified_file_contents = file_contents_as_string.dup

    multiline_comment_counter = 1

    multiline_comments_start = find_all_matching_indices(file_contents_as_string,"=begin")

    multiline_comments_end = find_all_matching_indices(file_contents_as_string,"=end")

    for y in 0...multiline_comments_start.length

      start_of_multiline_comment = multiline_comments_start[y]

      end_of_multiline_comment = multiline_comments_end[y]

      multiline_comment = file_contents_as_string[start_of_multiline_comment..end_of_multiline_comment+3]

      modified_file_contents = modified_file_contents.gsub(multiline_comment,"--multiline_comment[#{multiline_comment_counter}]")

      multiline_comment_counter += 1

      multiline_comments << multiline_comment


    end

    temporary_nila_file = find_file_path(nila_file_path,".nila") + "temp_nila.nila"

    output_js_file = find_file_path(nila_file_path,".nila") + find_file_name(nila_file_path,".nila") + ".js"

    file_id = open(temporary_nila_file, 'w')

    file_id2 = open(output_js_file, 'w')

    file_id.write(modified_file_contents)

    file_id2.write("//Written in Nila and compiled to Javascript. Have fun!\n\n")

    file_id.close()

    file_id2.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    comments = multiline_comments.dup

    return line_by_line_contents,comments,temporary_nila_file,output_js_file

  end

  def split_semicolon_seperated_expressions(input_file_contents)

    modified_file_contents = input_file_contents.dup

    input_file_contents.each_with_index do |line,index|

      if line.include?("\"")

        first_index = line.index("\"")

        modified_line = line.sub(line[first_index..line.index("\"",first_index+1)],"--string")

      elsif line.include?("'")

        first_index = line.index("'")

        modified_line = line.sub(line[first_index..line.index("'",first_index+1)],"--string")

      else

        modified_line = line

      end

      if modified_line.include?(";")

        replacement_line = modified_file_contents[index]

        replacement_line = replacement_line.split(";").join("\n\n")

        modified_file_contents[index] = replacement_line

      end

    end

    return modified_file_contents

  end

  def compile_heredoc_strings(input_file_contents,temporary_nila_file)

    #This method will compile all the Heredoc strings in Nila into pure
    #Javascript strings. Ruby has two types of Heredocs. Currently, Nila doesn't support both of them.
    #Here is an example of what Nila supports

    #long_passage = <<-ipsumtext
    #
    #Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
    #incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud
    #exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute
    #irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
    #pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia
    #deserunt mollit anim id est laborum.
    #
    #ipsumtext

    #Heredocs preserve all the formatting

    def find_all_matching_indices(input_string,pattern)

      locations = []

      index = input_string.index(pattern)

      while index != nil

        locations << index

        index = input_string.index(pattern,index+1)


      end

      return locations


    end

    joined_file_contents = input_file_contents.join

    modified_file_contents = joined_file_contents.dup

    heredoc_start_locations = find_all_matching_indices(joined_file_contents,"<<-")

    heredoc_start_locations.each do |location|

      string_extract = joined_file_contents[location..-1]

      end_of_first_line = string_extract.index("\n")

      name_of_heredoc = string_extract[3...end_of_first_line].rstrip

      heredoc_start,heredoc_end = find_all_matching_indices(string_extract,name_of_heredoc)

      heredoc = string_extract[heredoc_start..heredoc_end+name_of_heredoc.length-1]

      heredoc_content = heredoc.split(name_of_heredoc)

      heredoc_content = heredoc_content[1].lstrip.rstrip.gsub("\n","\\n").gsub("\t","\\t")

      modified_file_contents = modified_file_contents.sub(string_extract[heredoc_start-3..heredoc_end+name_of_heredoc.length-1],"\""+heredoc_content+"\"")

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(modified_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents

  end

  def compile_interpolated_strings(input_file_contents)

    modified_file_contents = input_file_contents.dup

    input_file_contents.each_with_index do |line,index|

      if line.include?("\#{")

        interpolated_strings = line.scan(/\#{\S{1,}}/)

        interpolated_strings.each do |interpol|

          string_split = line.split(interpol)

          if string_split[1].eql?("\"\n")

            replacement_string = "\" + " + interpol[2...-1]

            modified_file_contents[index] = modified_file_contents[index].sub(interpol+"\"",replacement_string)

          elsif string_split[1].eql?("\")\n")

            replacement_string = "\" + " + interpol[2...-1]

            modified_file_contents[index] = modified_file_contents[index].sub(interpol+"\"",replacement_string)

          else

            replacement_string = "\" + " + interpol[2...-1] + " + \""

            modified_file_contents[index] = modified_file_contents[index].sub(interpol,replacement_string)

          end

        end

      end

    end

    return modified_file_contents

  end

  def replace_singleline_comments(input_file_contents)

    single_line_comments = []

    singleline_comment_counter = 1

    for x in 0...input_file_contents.length

      current_row = input_file_contents[x]

      if current_row.include?("#")

        comment_start = current_row.index("#")

        if current_row[comment_start+1] != "{"

          comment = current_row[comment_start..-1]

          single_line_comments << comment

          current_row = current_row.gsub(comment,"--single_line_comment[#{singleline_comment_counter}]")

          singleline_comment_counter += 1

        end

      end

      input_file_contents[x] = current_row

    end

    return input_file_contents,single_line_comments

  end

  def replace_named_functions(nila_file_contents,temporary_nila_file)

    def extract_array(input_array,start_index,end_index)

      return input_array[start_index..end_index]

    end

    end_locations = []

    key_word_locations = []

    start_blocks = []

    end_blocks = []

    nila_regexp = /(def )/

    named_code_blocks = []

    for x in 0...nila_file_contents.length

      current_row = nila_file_contents[x]

      if current_row.index(nila_regexp) != nil

        key_word_locations << x

      elsif current_row.include?("end\n")

        end_locations << x


      end


    end

    modified_file_contents = nila_file_contents.dup

    for y in 0...end_locations.length

      current_location = end_locations[y]

      current_string = modified_file_contents[current_location]

      finder_location = current_location

      while current_string.index(nila_regexp) == nil

        finder_location -= 1

        current_string = modified_file_contents[finder_location]

      end

      code_block_begin = finder_location

      code_block_end = current_location

      start_blocks << code_block_begin

      end_blocks << code_block_end

      code_block_begin_string_split = modified_file_contents[code_block_begin].split(" ")

      code_block_begin_string_split[0] = code_block_begin_string_split[0].reverse

      code_block_begin_string = code_block_begin_string_split.join(" ")

      modified_file_contents[code_block_begin] = code_block_begin_string

    end

    final_modified_file_contents = nila_file_contents.dup

    joined_file_contents = final_modified_file_contents.join

    while start_blocks.length != 0

      top_most_level = start_blocks.min

      top_most_level_index = start_blocks.index(top_most_level)

      matching_level = end_blocks[top_most_level_index]

      named_code_blocks << extract_array(final_modified_file_contents,top_most_level,matching_level)

      start_blocks.delete_at(top_most_level_index)

      end_blocks.delete(matching_level)

    end

    codeblock_counter = 1

    named_functions = named_code_blocks.dup

    nested_functions = []

    named_code_blocks.each do |codeblock|

      if joined_file_contents.include?(codeblock.join)

        joined_file_contents = joined_file_contents.sub(codeblock.join,"--named_function[#{codeblock_counter}]\n")

        codeblock_counter += 1

        nested_functions = nested_functions + [[]]

      else

        nested_functions[codeblock_counter-2] << codeblock

        named_functions.delete(codeblock)

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents,named_functions,nested_functions


  end

  def get_variables(input_file_contents,temporary_nila_file)

    #This method is solely focused on getting a list of variables to be declared.
    #Since Javascript is a dynamic language, Nila doesn't have to worry about following up on those variables.

    #Semicolons are required in Javascript for successful compilation. So this method adds semicolons at the end of each
    #variable usage statements.

    variables = []

    for x in 0...input_file_contents.length

      current_row = input_file_contents[x]

      #The condition below verifies if the rows contain any equation operators.

      if current_row.include?("=")

        current_row = current_row.rstrip + "\n"

        current_row_split = current_row.split("=")

        for y in 0...current_row_split.length

          current_row_split[y] = current_row_split[y].strip


        end

        variables << current_row_split[0]


      end

      input_file_contents[x] = current_row

    end

    file_contents_as_string = input_file_contents.join

    file_id = open(temporary_nila_file, 'w')

    file_id.write(file_contents_as_string)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    variable_declaration_string = "var " + variables.uniq.join(", ") + "\n\n"

    line_by_line_contents = [variable_declaration_string,line_by_line_contents].flatten

    return variables.uniq,line_by_line_contents

  end

  def remove_question_marks(input_file_contents,variable_list,temporary_nila_file)

    #A method to remove question marks from global variable names. Local variables are dealt
    #with in their appropriate scope.

    #Params:
    #input_file_contents => An array containing the contents of the input nila file
    #variable_list => An array containing all the global variables declared in the file
    #temporary_nila_file => A file object used to write temporary contents

    #Example:

    #Nila
    #isprime? = false

    #Javascript Output
    #var isprime;
    #isprime = false;

    #Returns a modified input_file_contents with all the question marks removed

    joined_file_contents = input_file_contents.join

    variable_list.each do |var|

      if var.include? "?"

        joined_file_contents = joined_file_contents.gsub(var,var[0...-1])

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents

  end

  def compile_arrays(input_file_contents)

    #Currently the following kinds of array constructs are compilable

    # 1. %w{} syntax
    # 2. Range - Coming soon!

    def extract(input_string,pattern_start,pattern_end)

      def find_all_matching_indices(input_string,pattern)

        locations = []

        index = input_string.index(pattern)

        while index != nil

          locations << index

          index = input_string.index(pattern,index+1)


        end

        return locations


      end

      all_start_locations = find_all_matching_indices(input_string,pattern_start)

      all_end_locations = find_all_matching_indices(input_string,pattern_end)

      pattern = []

      all_start_locations.each_with_index do |location,index|

        pattern << input_string[location..all_end_locations[index]]

      end

      return pattern

    end

    def compile_w_syntax(input_string)

      modified_input_string = input_string[3...-1]

      string_split = modified_input_string.split(" ")

      return string_split.to_s

    end

    modified_file_contents = input_file_contents.dup

    input_file_contents.each_with_index do |line,index|

      if line.include?("%w{")

        string_arrays = extract(line,"%w{","}")

        string_arrays.each do |array|

          modified_file_contents[index] = modified_file_contents[index].sub(array,compile_w_syntax(array))

        end

      end

    end

    return modified_file_contents

  end

  def compile_named_functions(input_file_contents,named_code_blocks,nested_functions,temporary_nila_file)

    #This method compiles all the named Nila functions. Below is an example of what is meant
    #by named/explicit function

    #def square(input_number)
    #
    #   return input_number*input_number
    #
    #end

    #The above function will compile to

    #function square(input_number) {
    #
    #  return input_number*input_number;
    #
    # }

    def is_parameterless?(input_function_block)

      if input_function_block[0].include?("(")

        false

      else

        true

      end

    end

    def lexical_scoped_variables(input_function_block)

      #This method will pickup and declare all the variables inside a function block. In future, this method will be
      #merged with the get variables method

      variables = []

      input_function_block.each do |line|

        if line.include? "="

          current_line_split = line.strip.split("=")

          variables << current_line_split[0].rstrip

        end

      end

      variables.uniq

    end

    def remove_question_marks(input_file_contents,input_list,temporary_nila_file)

      joined_file_contents = input_file_contents.join

      input_list.each do |element|

        if element.include? "?"

          joined_file_contents = joined_file_contents.gsub(element,element[0...-1])

        end

      end

      file_id = open(temporary_nila_file, 'w')

      file_id.write(joined_file_contents)

      file_id.close()

      line_by_line_contents = read_file_line_by_line(temporary_nila_file)

      return line_by_line_contents

    end

    def add_auto_return_statement(input_array)

      joined_array = input_array.join

      reversed_input_array = input_array.reverse

      if !joined_array.include?("return ")

        rejected_array = reversed_input_array.reject {|content| content.eql?("\n") || content.lstrip.eql?("}\n")}

        last_statement = rejected_array[0]

        replacement_string = "return #{last_statement.lstrip}"

        input_array[input_array.index(last_statement)] = replacement_string

      end

      return input_array

    end

    def compile_function(input_array,temporary_nila_file)

      modified_input_array = input_array.dup

      if is_parameterless?(modified_input_array)

        if modified_input_array[0].include?("--single")

          modified_input_array[0] = input_array[0].sub "def","function"

          interim_string = modified_input_array[0].split("--single")

          modified_input_array[0] =  interim_string[0].rstrip + "() {\n--single" + interim_string[1]


        elsif modified_input_array[0].include?("--multi")

          modified_input_array[0] = input_array[0].sub "def","function"

          interim_string = modified_input_array[0].split("--multi")

          modified_input_array[0] =  interim_string[0].rstrip + "() {\n--multi" + interim_string[1]

        else

          modified_input_array[0] = input_array[0].sub "def","function"

          modified_input_array[0] = modified_input_array[0].rstrip + "() {\n"

        end

      else

        if modified_input_array[0].include?("--single")

          modified_input_array[0] = input_array[0].sub "def","function"

          interim_string = modified_input_array[0].split("--single")

          modified_input_array[0] =  interim_string[0].rstrip + " {\n--single" + interim_string[1]


        elsif modified_input_array[0].include?("--multi")

          modified_input_array[0] = input_array[0].sub "def","function"

          interim_string = modified_input_array[0].split("--multi")

          modified_input_array[0] =  interim_string[0].rstrip + " {\n--multi" + interim_string[1]

        else

          modified_input_array[0] = input_array[0].sub "def","function"

          modified_input_array[0] = modified_input_array[0].rstrip + " {\n"

        end

      end

      modified_input_array[-1] = input_array[-1].sub "end","}\n"

      variables = lexical_scoped_variables(modified_input_array)

      if !variables.empty?

        variable_string = "\nvar " + variables.join(", ") + "\n"

        modified_input_array.insert(1,variable_string)

      end

      modified_input_array = remove_question_marks(modified_input_array,variables,temporary_nila_file)

      modified_input_array = add_auto_return_statement(modified_input_array)

      return modified_input_array

    end

    def extract_function_name(input_code_block)

      first_line = input_code_block[0]

      first_line_split = first_line.split(" ")

      if first_line_split[1].include?("(")

        function_name,parameters = first_line_split[1].split("(")

      else

        function_name = first_line_split[1]

      end

      return function_name

    end

    joined_file_contents = input_file_contents.join

    codeblock_counter = 1

    function_names = []

    named_code_blocks.each do |codeblock|

      function_names[codeblock_counter-1] = []

      joined_file_contents = joined_file_contents.sub("--named_function[#{codeblock_counter}]\n",compile_function(codeblock,temporary_nila_file).join)

      codeblock_counter += 1

      current_nested_functions = nested_functions[codeblock_counter-2]

      function_names[codeblock_counter-2] << extract_function_name(codeblock)

      current_nested_functions.each do |nested_function|

        function_names[codeblock_counter-2] << extract_function_name(nested_function)

        joined_file_contents = joined_file_contents.sub(nested_function.join,compile_function(nested_function,temporary_nila_file).join)

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents,function_names
    
  end

  def compile_custom_function_map(input_file_contents)

    function_map = ["puts"]

    function_map_replacements = {

        "puts" => "console.log"

    }

    modified_file_contents = input_file_contents.dup

    input_file_contents.each_with_index do |line,index|

      function_map.each do |function|

        if line.include?(function+"(") or line.include?(function+" ")

          modified_file_contents[index] = line.sub(function,function_map_replacements[function])

        end

      end

    end

    return modified_file_contents,function_map_replacements.values

  end

  def compile_whitespace_delimited_functions(input_file_contents,function_names,temporary_nila_file)

    def extract(input_string,pattern_start,pattern_end)

      def find_all_matching_indices(input_string,pattern)

        locations = []

        index = input_string.index(pattern)

        while index != nil

          locations << index

          index = input_string.index(pattern,index+1)


        end

        return locations


      end

      all_start_locations = find_all_matching_indices(input_string,pattern_start)

      pattern = []

      all_start_locations.each do |location|

        extracted_string = input_string[location..-1]

        pattern << extracted_string[0..extracted_string.index(pattern_end)]

      end


      return pattern

    end

    joined_file_contents = input_file_contents.join

    function_names.each do |list_of_functions|

      list_of_functions.each do |function|

        matching_strings = extract(joined_file_contents,function+" ","\n")

        matching_strings.each do |string|

          modified_string = string.dup

          modified_string = modified_string.sub(function+" ",function+"(")

          modified_string = modified_string.sub("\n",")\n")

          joined_file_contents = joined_file_contents.sub(string,modified_string)

        end

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents

  end

  def compile_conditional_structures(input_file_contents,temporary_nila_file)

    #Currently the following conditional structures have been implemented

    #1. If, Elsif, Else Statement



  end

  def compile_comments(input_file_contents,comments,temporary_nila_file)

    #This method converts Nila comments into pure Javascript comments. This method
    #handles both single line and multiline comments.

    file_contents_as_string = input_file_contents.join

    single_line_comments = comments[0]

    multiline_comments = comments[1]

    single_line_comment_counter = 1

    multi_line_comment_counter = 1

    for x in 0...single_line_comments.length

      current_singleline_comment = "--single_line_comment[#{single_line_comment_counter}]"

      replacement_singleline_string = single_line_comments[x].sub("#","//")

      file_contents_as_string = file_contents_as_string.sub(current_singleline_comment,replacement_singleline_string)

      single_line_comment_counter += 1


    end

    for y in 0...multiline_comments.length

      current_multiline_comment = "--multiline_comment[#{multi_line_comment_counter}]"

      replacement_multiline_string = multiline_comments[y].sub("=begin","/*\n")

      replacement_multiline_string = replacement_multiline_string.sub("=end","\n*/")

      file_contents_as_string = file_contents_as_string.sub(current_multiline_comment,replacement_multiline_string)

      multi_line_comment_counter += 1

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(file_contents_as_string)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    line_by_line_contents

  end

  def add_semicolons(input_file_contents)

    def comment(input_string)

      if input_string.include?("--single_line_comment")

        true

      elsif input_string.include?("--multiline_comment")

        true

      else

        false

      end

    end

    reject_regexp = /(function |if |else|switch |case|while |for )/

    modified_file_contents = []

    input_file_contents.each do |line|

      if line.index(reject_regexp) == nil

        if !comment(line)

          if !line.eql?("\n")

            if !line.lstrip.eql?("}\n")

              if !line.lstrip.eql?("}\n\n")

                modified_file_contents << line.rstrip + ";\n\n"

              else

                modified_file_contents << line

              end

            else

              modified_file_contents << line

            end

          else

            modified_file_contents << line

          end

        else

          modified_file_contents << line

        end

      else

        modified_file_contents << line

      end

    end

    modified_file_contents

  end

  def pretty_print_javascript(javascript_file_contents,temporary_nila_file)

    def reset_tabs(input_file_contents)

      #This method removes all the predefined tabs to avoid problems in
      #later parts of the beautifying process.

      for x in 0...input_file_contents.length

        current_row = input_file_contents[x]

        if !current_row.eql?("\n")

          current_row = current_row.lstrip

        end

        input_file_contents[x] = current_row


      end

      return input_file_contents

    end

    def find_all_matching_indices(input_string,pattern)

      locations = []

      index = input_string.index(pattern)

      while index != nil

        locations << index

        index = input_string.index(pattern,index+1)


      end

      return locations


    end

    def convert_string_to_array(input_string,temporary_nila_file)

      file_id = open(temporary_nila_file, 'w')

      file_id.write(input_string)

      file_id.close()

      line_by_line_contents = read_file_line_by_line(temporary_nila_file)

      return line_by_line_contents

    end

    def previous_formatting(input_string,tab_counter,temporary_nila_file)

      string_as_array = convert_string_to_array(input_string,temporary_nila_file)

      modified_array = []

      string_as_array.each do |line|

        modified_array << "  "*tab_counter + line

      end

      return modified_array.join

    end

    javascript_regexp = /(function |function\()/

    locations = []

    javascript_file_contents = reset_tabs(javascript_file_contents)

    joined_file_contents = javascript_file_contents.join

    code_block_starting_locations = find_all_matching_indices(joined_file_contents,javascript_regexp)

    code_block_ending_locations = find_all_matching_indices(joined_file_contents,"}")

    combined_location = [code_block_starting_locations,code_block_ending_locations.dup].flatten.sort

    last_matching_location = 0

    self_invoking_function_extract = joined_file_contents[code_block_starting_locations[0]..code_block_ending_locations[-1]]

    self_invoking_function_array = convert_string_to_array(self_invoking_function_extract,temporary_nila_file)

    combined_location.delete_at(0); combined_location.delete_at(-1); code_block_ending_locations.delete_at(-1); code_block_starting_locations.delete_at(0)

    modified_self_invoking_array = self_invoking_function_array.dup

    for x in 1...self_invoking_function_array.length-1

      modified_self_invoking_array[x] = "  " + self_invoking_function_array[x]

    end

    modified_self_invoking_array[-1] = "\n\n" + modified_self_invoking_array[-1]

    while code_block_ending_locations.length > 0

      matching_location = combined_location[combined_location.index(code_block_ending_locations[0])-1]

      location_among_start_locations = code_block_starting_locations.index(matching_location)

      locations << [[matching_location,combined_location[combined_location.index(code_block_ending_locations[0])]]]

      code_block_ending_locations.delete_at(0)

      if code_block_ending_locations.length > 0

        for x in location_among_start_locations-1..last_matching_location

          locations[-1] << [code_block_starting_locations[x],code_block_ending_locations[0]]

          code_block_ending_locations.delete_at(0)

        end

      end

      last_matching_location = location_among_start_locations + 1

    end

    modified_locations = []

    locations.each do |loc|

      modified_locations << loc.sort

    end

    modified_joined_file_contents = joined_file_contents.dup

    modified_joined_file_contents = modified_joined_file_contents.sub(self_invoking_function_extract,modified_self_invoking_array.join)

    modified_locations.each do |location|

      soft_tabs_counter = 2

      location.each do |sublocation|

        string_extract = joined_file_contents[sublocation[0]..sublocation[1]]

        string_extract_array = convert_string_to_array(string_extract,temporary_nila_file)

        if soft_tabs_counter > 1

          string_extract_array[0] = "  "*(soft_tabs_counter-1) + string_extract_array[0]

          string_extract_array[-1] = "  "*(soft_tabs_counter-1) + string_extract_array[-1]

        end

        for x in 1...string_extract_array.length-1

          string_extract_array[x] = "  "*soft_tabs_counter + string_extract_array[x]

        end

        if soft_tabs_counter > 1

          modified_joined_file_contents = modified_joined_file_contents.sub(previous_formatting(string_extract,soft_tabs_counter-1,temporary_nila_file),string_extract_array.join)

        else

          modified_joined_file_contents = modified_joined_file_contents.sub(string_extract,string_extract_array.join)

        end

        soft_tabs_counter += 1

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(modified_joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    var_declaration_index = 0

    for x in 0...line_by_line_contents.length

      current_row = line_by_line_contents[x]

      if current_row.lstrip.include?("var ")

        var_declaration_index = x

        break

      end

    end

    empty_check = line_by_line_contents[x+1..x+4]

    empty_check.each_with_index do |content,index|

      empty_check[index] = content.lstrip

    end

    empty_check = empty_check.delete_if {|content| content.empty?}

    if empty_check.empty?

      line_by_line_contents.delete_at(x+1);line_by_line_contents.delete_at(x+2)

    end

    return line_by_line_contents

  end

  def pretty_print_nila(input_file_contents)

    #Implementation is pending

  end

  def static_analysis(input_file_contents)

    #Implementation is pending

  end

  def create_self_invoking_function(input_file_contents)

    # A feature imported from Coffeescript. This makes all the function private by default
    # and prevents global variables from leaking.

    modified_file_contents = ["(function() {\n\n",input_file_contents,"\n\n}).call(this);\n"].flatten

    return modified_file_contents

  end

  def compile_license_functions(input_file_contents,temporary_nila_file)

    #This method will make it easier for developers to add open source licensing to their projects

    #Currently the following licenses are supported

    #1. MIT License

    #Example of MIT License => mit_license(year,authors)

    #mit_license("2013","Adhithya Rajasekaran, Sri Madhavi Rajasekaran")

    def find_all_matching_indices(input_string,pattern)

      locations = []

      index = input_string.index(pattern)

      while index != nil

        locations << index

        index = input_string.index(pattern,index+1)


      end

      return locations


    end

    license_functions = ["mit_license(","apache_license"]

    mit_license = <<-licensetext

      /*

      Copyright yer, <auth>

      Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”),
      to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
      and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

      The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

      THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
      IN THE SOFTWARE.

      */


    licensetext

    apache_license = <<-licensetext

      /*

      Copyright [yer] [auth]

      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.

      */


    licensetext

    license_texts = [mit_license,apache_license]

    license_params = [2,2]

    license_replaceables = ["yer","auth","orgg"]

    joined_file_contents = input_file_contents.join

    license_functions.each_with_index do |function,index|

      function_locations = find_all_matching_indices(joined_file_contents,function)

      function_locations.each do |location|

        string_extract = joined_file_contents[location..-1]

        function_end = string_extract.index(")")

        function_call = string_extract[0..function_end]

        parameters = function_call.split(function)[1][0...-1]

        parameters = parameters.split(":")

        parameters.each_with_index do |param,index|

          parameters[index] = param[1...-1]

        end

        replacement_string = license_texts[index]

        for x in 0...parameters.length

          replacement_string = replacement_string.sub(license_replaceables[x],parameters[x])

        end

        replacement_array = replacement_string.split("\n")

        modified_replacement_array = replacement_array.dup

        replacement_array.each_with_index do |line,index|

          modified_replacement_array[index] = line.lstrip

        end

        replacement_string = replacement_array.join("\n")

        if joined_file_contents.include?(function_call+";\n")

          joined_file_contents = joined_file_contents.sub(function_call+";\n","")

        else

          joined_file_contents = joined_file_contents.sub(function_call+";","")

        end

        joined_file_contents = replacement_string.lstrip + "\n\n"  + joined_file_contents

      end

    end

    file_id = open(temporary_nila_file, 'w')

    file_id.write(joined_file_contents)

    file_id.close()

    line_by_line_contents = read_file_line_by_line(temporary_nila_file)

    return line_by_line_contents

  end

  def output_javascript(file_contents,output_file,temporary_nila_file)

    file_id = open(output_file, 'w')

    File.delete(temporary_nila_file)

    file_id.write("// Generated by Nilac 0.0.1 Visit http://adhithyan15.github.com/nila to know more\n\n")

    file_id.write(file_contents.join)

    file_id.close()

  end

  file_contents = read_file_line_by_line(input_file_path)

  file_contents = extract_parsable_array(file_contents)

  file_contents,multiline_comments,temp_file,output_js_file = replace_multiline_comments(file_contents,input_file_path)

  file_contents = split_semicolon_seperated_expressions(file_contents)

  file_contents = compile_heredoc_strings(file_contents,temp_file)

  file_contents = compile_interpolated_strings(file_contents)

  file_contents,singleline_comments = replace_singleline_comments(file_contents)

  file_contents,named_functions,nested_functions = replace_named_functions(file_contents,temp_file)

  comments = [singleline_comments,multiline_comments]

  list_of_variables,file_contents = get_variables(file_contents,temp_file)

  file_contents = compile_arrays(file_contents)

  file_contents, function_names = compile_named_functions(file_contents,named_functions,nested_functions,temp_file)

  file_contents, ruby_functions = compile_custom_function_map(file_contents)

  function_names << ruby_functions

  file_contents = compile_whitespace_delimited_functions(file_contents,function_names,temp_file)

  file_contents = remove_question_marks(file_contents,list_of_variables,temp_file)

  file_contents = add_semicolons(file_contents)

  file_contents = compile_comments(file_contents,comments,temp_file)

  file_contents = create_self_invoking_function(file_contents)

  file_contents = compile_license_functions(file_contents,temp_file)

  file_contents = pretty_print_javascript(file_contents,temp_file)

  output_javascript(file_contents,output_js_file,temp_file)


end

def create_executable(input_file)

  windows_output = `ocra --add-all-core #{input_file}`

end

def create_mac_executable(input_file)

  def read_file_line_by_line(input_path)

    file_id = open(input_path)

    file_line_by_line = file_id.readlines()

    file_id.close

    return file_line_by_line

  end

  mac_file_contents = ["#!/usr/bin/env ruby"] + read_file_line_by_line(input_file)

  mac_file_path = input_file.sub(".rb","")

  file_id = open(mac_file_path,"w")

  file_id.write(mac_file_contents.join)

  file_id.close

end

def find_file_name(input_path,file_extension)

  extension_remover = input_path.split(file_extension)

  remaining_string = extension_remover[0].reverse

  path_finder = remaining_string.index("\\")

  remaining_string = remaining_string.reverse

  return remaining_string[remaining_string.length-path_finder..-1]

end

options = {}

OptionParser.new do |opts|
  opts.banner = "Usage: nilac [options] nilafile"

  opts.on("-c", "--compile FILE", "Compile to Javascript") do |file|
    current_directory = Dir.pwd
    file_path = current_directory + "/" + file
    compile(file_path)
    puts "Compilation Successful!"

  end

  opts.on("-r", "--run FILE", "Compile to Javascript and Run") do |file|
    current_directory = Dir.pwd

    file_path = current_directory + "/" + file

    compile(file_path)

    js_file_name = find_file_name(file_path,".nila") + ".js"

    node_output = `node #{js_file_name}`

    puts node_output

  end

  opts.on("-b", "--build", "Builds Itself") do

    create_executable("nilac.rb")

    puts "Build Successful!"

  end

  opts.on("-m", "--buildmac", "Builds Mac Executables") do

    file_path = Dir.pwd + "/nilac.rb"

    create_mac_executable(file_path)

    puts "Build Successful!"

  end

  opts.on("-v", "--version", "Version of Nilac") do

    version_number = "0.0.1"

    puts "Current Nilac Version: #{version_number}"

  end

end.parse!