object Test extends App
{
  trait IRenderer
  {
    def renderResponse
  }

  class Renderer(val response: GateResponse) extends IRenderer
  {
    def renderResponse = {
      print(response)
    }
  }

  trait IRendererFactory
  {
    def createRenderer(response: GateResponse): IRenderer
  }

  class CardRendererFactory extends IRendererFactory
  {
    def createRenderer(response: GateResponse): IRenderer = {
      new Renderer(response)
    }
  }

  abstract class BaseParser(val rendererFactory: IRendererFactory)
  {
    def run() = {
      val response = process()
      renderResponse(response)
    }

    protected def process(): GateResponse = {
      val gateRequest = buildRequest()

      val response = checkBusinessRulesAndProcessRequest(gateRequest)
      response
    }


    protected def buildRequest(): GateRequest

    private def renderResponse(response: GateResponse) = {
      rendererFactory.createRenderer(response).renderResponse
    }

    private def checkBusinessRulesAndProcessRequest(request: GateRequest) = {
      val response = processRequest(request)
      response
    }

    private def processRequest(request: GateRequest): GateResponse = {
      request.getResponse
    }
  }

  class CardParser(rendererFactory: IRendererFactory) extends BaseParser(rendererFactory: IRendererFactory)
  {
    override def process() = {
      new CardResponse
    }

    override protected def buildRequest() = {
      new CardRequest()
    }
  }


  class GateResponse
  class CardResponse extends GateResponse

  abstract class GateRequest
  {
    def getResponse(): GateResponse
  }
  class CardRequest extends GateRequest
  {
    def getResponse() = {
      new CardResponse()
    }
  }


  val cardParser = new CardParser(new CardRendererFactory)
  cardParser.run()
}