#!/usr/bin/env ruby
require 'spec'
require 'madlibs'

context "Match QUESTION_DELIMITER: " do
specify "no questions" do
  "no questions".match(MadLibs::QUESTION_DELIMITER).should_be nil
end
specify "delimit simple question" do
  match = "this ((that)) other".match(MadLibs::QUESTION_DELIMITER)
  match.should_not_be nil
  match[1].should_equal "((that))"
end
specify "delimit complex question" do
  match = "this ((that:thing)) other".match(MadLibs::QUESTION_DELIMITER)
  match.should_not_be nil
  match[1].should_equal "((that:thing))"
end
specify "delimit one question from multiple questions" do
  match = "this ((that)) other ((next)) one".match(MadLibs::QUESTION_DELIMITER)
  match.should_not_be nil
  match[1].should_equal "((that))"
end
specify "split works as expected" do
  tokens = "this ((question)) is".split(MadLibs::QUESTION_DELIMITER)
  tokens.should_equal ["this ","((question))", " is"]
end

specify "delimits questions with line break" do
  match = "this ((that\nthing)) other".match(MadLibs::QUESTION_DELIMITER)
  match.should_not_be nil
  match[1].should_equal "((that\nthing))"
end
end

context "Match QUESTION_PARSER: " do
specify "question parser matches" do
  "no question".should_not_match(MadLibs::QUESTION_PARSER)
  "this has ((a question)) in it".should_match(MadLibs::QUESTION_PARSER)
end
specify "question parser parses" do
  match = "This has ((a question)) in it".match(MadLibs::QUESTION_PARSER)
  match.should_not_be nil
  match[1].should_equal "a question"
end
specify "question has line break" do
  match = "This has ((a\nquestion)) in it".match(MadLibs::QUESTION_PARSER)
  match.should_not_be nil
  match[1].should_equal "a\nquestion"
end
specify "question has surrounding whitespace" do
  match = "This has (( a question )) in it".match(MadLibs::QUESTION_PARSER)
  match.should_not_be nil
  match[1].should_equal "a question"
end
end

context "Translate" do
setup do
  @asker = mock "asker"
  @ml = MadLibs.new(@asker)
end

specify "empty document" do
  @ml.translate("").should_equal ""
end

specify "document with no questions" do
  @ml.translate("Bob").should_equal "Bob"
end

specify "document with one simple question" do
  @asker.should_receive(:ask).once.with("color").and_return("blue")
  @ml.translate("The sky is ((color)).").should_equal "The sky is blue."
end

specify "document with two simple questions" do
  @asker.should_receive(:ask).with("color").and_return("red")
  @asker.should_receive(:ask).with("texture").and_return("rough")
  @ml.translate("My ((color)) hankie is ((texture)).").
  should_equal "My red hankie is rough."
end

specify "line break inside question treated like space" do
  @asker.should_receive(:ask).once.with("a color").and_return("blue")
  @ml.translate("The sky is ((a\ncolor)).").should_equal "The sky is blue."
end

specify "named question with no replacement" do
  @asker.should_receive(:ask).once.with("color").and_return("blue")
  @ml.translate("The sky is ((skycolor:color)).").should_equal "The sky is blue."
end

specify "named question with two colons" do
  @asker.should_receive(:ask).once.with("color:sky").and_return("blue")
  @ml.translate("The sky is ((skycolor:color:sky)).").should_equal "The sky is blue."
end

specify "named question with replacement" do
  @asker.should_receive(:ask).once.with("color").and_return("blue")
  @ml.translate("The sky is ((skycolor:color)) on ((skycolor)).").
  should_equal "The sky is blue on blue."
end

specify "named question with named replacement" do
  @asker.should_receive(:ask).once.with("a noun").and_return("stone")
  @ml.translate("I found a ((thing:a noun)), and a ((b:thing)), and a ((b)).").
  should_equal "I found a stone, and a stone, and a stone."
end

specify "null question" do
  @ml.translate("This (()) is a null question").
  should_equal "This  is a null question"
end

specify "null name" do
  @asker.should_receive(:ask).once.with("flavor").and_return("sour")
  @ml.translate("This is ((:flavor)).").should_equal "This is sour."
end

specify "null name and question" do
  @ml.translate("This is a null question too ((:)).").
  should_equal("This is a null question too .")
end
end

context "console asker:" do
setup do
 @reader = mock "reader"
 @writer = mock "writer"
 @asker = MadLibs::Asker.new(@reader, @writer)
end

specify "asker delivers prompt and asks for input" do
 @writer.should_receive(:puts).once.with("Please enter a flavor:")
 @reader.should_receive(:gets).once.and_return("sour")
 @asker.ask("a flavor").should_equal "sour"
end
end

class MadLibs
  QUESTION_DELIMITER=/(\(\(.*?\)\))/m #multiline mode
  QUESTION_PARSER=/\(\(\s*(.*?)\s*\)\)/m #multiline mode

  def initialize(asker)
    @asker = asker
    @named_answers = {}
  end

  def translate(text)
    questions_and_text = split_questions_from_text(text)
    answers_and_text = replace_questions_with_answers(questions_and_text)
    answers_and_text.join
  end

  def split_questions_from_text(text)
    text.split(QUESTION_DELIMITER)
  end

  def replace_questions_with_answers(questions_and_text)
    questions_and_text.map do |question_or_text|
      replace_question_with_answer(question_or_text)
    end
  end

  def replace_question_with_answer(question_or_text)
    question = extract_question(question_or_text)
    if (question)
      get_answer(question)
    else #text
      question_or_text
    end
  end

  def extract_question(question_or_text)
    question_match = question_or_text.match(QUESTION_PARSER)
    if (question_match)
      extracted_question = question_match[1]
      return squeeze_whitespace(extracted_question)
    else
      return nil
    end
  end

  def squeeze_whitespace(text)
    text.gsub(/\s+/," ")
  end

  def get_answer(question)
    question,name = parse_question(question)
    named_answer = @named_answers[question]
    if named_answer
      answer = named_answer
    else
      answer = @asker.ask(question) if question
    end
    @named_answers[name] = answer if name
    answer
  end

  def parse_question(question)
    return [nil,nil] if question.empty?
    colon = question.index(":")
    if colon
      return separate_question_from_name(question,colon)
    else
      return [question,nil]
    end
  end

  def separate_question_from_name(question,colon)
    name = question[0..colon-1]
    question = question[colon+1..question.length]
    name = nil if name.empty?
    question = nil if question.empty?
    return [question,name]
  end
end

class Asker
  def initialize(reader, writer)
    @reader = reader
    @writer = writer
  end

  def ask(element)
    @writer.puts("Please enter " + element + ":")
    response = @reader.gets
    return response.chomp
  end
end

class MadLibs
  QUESTION_DELIMITER=/(\(\(.*?\)\))/m #multiline mode
  QUESTION_PARSER=/\(\(\s*(.*?)\s*\)\)/m #multiline mode
  attr_reader :asker, :named_answers
  def initialize(asker)
    @asker = asker
    @named_answers = {}
  end

  def translate(document)
    game = make_game(document)
    game.play(GameContext.new(@asker))
  end

  def make_game(document)
    q_and_t_strings = document.split(QUESTION_DELIMITER)
    tokens = q_and_t_strings.map {|s| parse_string_into_token(s)}
    MadLibsGame.new(tokens)
  end

  def parse_string_into_token(the_string)
    question_string = match_question_string(the_string)
    if (question_string)
      parse_question(question_string)
    else
      Text.new(the_string)
    end
  end

  def match_question_string(question_or_text)
    question_match = question_or_text.match(QUESTION_PARSER)
    if (question_match)
      extracted_question = question_match[1]
      return squeeze_whitespace(extracted_question)
    else
      return nil
    end
  end

  def squeeze_whitespace(text)
    text.gsub(/\s+/," ")
  end

  def parse_question(question)
    return Question.new(nil,nil) if question.empty?
    colon = question.index(":")
    if colon
      query,name = separate_question_from_name(question,colon)
      return Question.new(query,name)
    else
      return Question.new(question,nil)
    end
  end

  def separate_question_from_name(question,colon)
    name = question[0..colon-1]
    question = question[colon+1..question.length]
    name = nil if name.empty?
    question = nil if question.empty?
    return [question,name]
  end

  class GameContext
    attr_reader :asker, :named_answers
    def initialize(asker)
      @asker = asker
      @named_answers = {}
    end
  end

  class MadLibsGame
    def initialize(tokens)
      @tokens = tokens
    end

    def play(context)
      text_and_answer_strings = @tokens.map {|token| token.process(context)}
      text_and_answer_strings.join
    end
  end

  class Question
    attr_reader :query, :name

    def initialize(query, name)
      @query = query
      @name = name
    end

    def process(context)
      named_answer = context.named_answers[@query]
      if named_answer
        answer = named_answer
      else
        answer = context.asker.ask(@query) if @query
      end
      context.named_answers[@name] = answer if @name
      answer
    end

  end

  class Text
    attr_reader :text

    def initialize(text)
      @text = text
    end

    def process(context)
      @text
    end
  end

  class Asker
    def initialize(reader, writer)
      @reader = reader
      @writer = writer
    end

    def ask(element)
      @writer.puts("Please enter " + element + ":")
      response = @reader.gets
      return response.chomp
    end
  end
end