require "abstracted_responder"

class AbstractResourcesController < ApplicationController
  self.responder = ::AbstractedResponder
  respond_to :html, :xml, :js, :json

  before_action :set_resource #, except: :index
  before_action :set_fab_button_options
  before_filter :set_parents, only: [ :new, :edit, :show ]
  before_action :set_resources, only: [:index, :print]
  before_action :set_variant_template

  before_filter :authenticate_user!
  after_action :verify_authorized
  # after_action  :manage_parenthood, only: [:create,:update,:destroy]

  # default implementation

  def prefer
    authorize resource
    if resource.prefer parent
      flash[:info] = t(:resource_preferred_correct)
      render :prefer, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_preferred_incorrect)
      render :prefer, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end

  def defer
    authorize resource
    if resource.defer parent
      flash[:info] = t(:resource_deferred_correct)
      render :defer, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_deferred_incorrect)
      render :defer, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end

  def activate
    authorize resource
    if resource.activate
      flash[:info] = t(:resource_activated_correct)
      render :activate, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_activated_incorrect)
      render :activate, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end

  def deactivate
    authorize resource
    if resource.deactivate
      flash[:info] = t(:resource_deactivated_correct)
      render :deactivate, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_deactivated_incorrect)
      render :deactivate, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end


  def attach
    authorize resource
    if resource.attach parent
      flash[:info] = t(:resource_attached_correct)
      render :attach, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_attached_incorrect)
      render :attach, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end

  def detach
    authorize resource
    if resource.detach parent
      flash[:info] = t(:resource_detached_correct)
      render :detach, layout: false, status: 200 and return
    else
      flash[:error] = t(:resource_detached_incorrect)
      render :detach, layout: false, status: 401 and return
    end

  rescue Exception => e
    scoop_from_error e
  end

  #
  # build an array of the resource - particular to <SELECT>
  def set_parents
    unless (resource_class.respond_to?( 'arraying') && resource? )
      @parents = []
    else
      @parents = resource_class.arraying({ order: 'name'}, resource.possible_parents)
    end
  rescue Exception => e
    scoop_from_error e
  end

  def show
    authorize resource
    respond_with resource
  rescue Exception => e
    scoop_from_error e
  end

  def new
    resource.parent_id = params[:parent_id] if resource.respond_to? :parent_id
    authorize resource
    respond_with resource
  rescue Exception => e
    scoop_from_error e
  end

  def edit
    authorize resource
    respond_with resource
  rescue Exception => e
    scoop_from_error e
  end

  PRINTSUCCESS = 1
  NOQUEUE = -1
  NOUSER = -2
  PRINTRECERROR = -3
  PRINTCMDERROR = -4
  PRINTLISTERROR = -5
  PRINTEXCEPTION = -99

  #
  # print this view - let the Class handle everything
  # returning either the ID to a print_job or false (in which case something went terribly wrong)
  #
  # always an Ajax call - hence will always update the print_jobs link with 'yellow'-blink
  # POST /printers/print.js
  # params[:id] holds records to be printed
  def print
    authorize resource, :print?
    if resources.any?
      if print_resources > 0
        flash[:info] = t(:resources_printed_correct)
        status = 200
      else
        flash[:error] = t(:resources_not_found_printjob_not_created)
        status = 301
      end
    else
      flash[:error] = I18n.oxt(:resources_not_found_printjob_not_created)
      status = 301
    end
    return if params[:download]
    render :print, layout: false, status: status and return
  rescue Exception => e
    scoop_from_error e
  end


  def index
    authorize resource_class, :index?
    respond_with resources
  rescue Exception => e
    scoop_from_error e
  end

  def create
    authorize resource
    respond_with(resource, location: redirect_after_create ) do |format|
      if resource.save && update_parenthood
        flash[:notice] = t('.success.created', resource: resource_class.to_s )
      else
        format.html { render action: :new, status: :unprocessable_entity }
        format.js { render action: :new, status: :unprocessable_entity }
      end
    end
  rescue Exception => e
    scoop_from_error e
  end

  def update
    authorize resource
    respond_with(resource, location: redirect_after_update) do |format|
      if resource.update_attributes(resource_params) && update_parenthood
        flash[:notice] = t('.success.updated', resource: resource_class.to_s )
      else
        format.html { render action: :edit, status: :unprocessable_entity }
        format.js { render action: :edit, status: :unprocessable_entity }
      end
    end
  rescue Exception => e
    scoop_from_error e
  end

  def destroy
    authorize resource
    result = true if resource.destroy && update_parenthood
    result ? (flash.now[:notice] = t('.success', resource: resource_class.to_s)) : (flash.now[:error] = t('.deleted.error',resource: resource_class.to_s))
    if result==true
      render layout:false, status: 200, locals: { result: true }
    else
      render layout:false, status: 301, locals: { result: true }
    end
  rescue Exception => e
    scoop_from_error e
  end

  def resource_params
    raise 'You need to "def resource_params" on the %sController! (see: http://blog.trackets.com/2013/08/17/strong-parameters-by-example.html)' % params[:controller].capitalize
  end

  def set_resource
    parent
    resource
  end

  def set_resources
    resources
  end

  def resource?
    !(%w{NilClass TrueClass FalseClass}.include? @resource.class.to_s)
  rescue Exception => e
    scoop_from_error e
  end

  def resource
    @resource ||= (_id.nil? ? new_resource : resource_class.find(_id) )
    return @resource if @resource.nil?
    @resource.current_user = (current_user || nil) if @resource.respond_to? :current_user
    @resource
  rescue Exception => e
    scoop_from_error e
  end

  # def resource=val
  #   @resource=val
  # end

  def new_resource
    return nil if resource_class.nil?
    return resource_class.new if resource_class.ancestors.include?( ActiveRecord::Base ) and !(params.include? resource_class.to_s.underscore) #[ 'create', 'update' ].include? params[:action]
    p = resource_params
    p=p.compact.first if p.class==Array
    return resource_class.new(p.merge(current_user: current_user)) if resource_class.ancestors.include? ActiveRecord::Base
    nil
  rescue Exception => e
    scoop_from_error e
  end

  def _id
    return nil if !params[:id] || params[:id]=="0"
    params[:id] || params["#{resource_class.to_s.downcase}_id".to_sym]
  rescue Exception => e
    scoop_from_error e
  end

  def resource_name options={}
    resource_class.table_name
  rescue Exception => e
    scoop_from_error e
    # resource_class.to_s.underscore.pluralize
  end

  def resource_class
    return @resource_class if resource?
    @resource_class ||= params[:controller].singularize.classify.constantize
  rescue Exception => e
    scoop_from_error e
  end

  def resource_class= val
    @resource_class = val
  end

  def parent
    @parent ||= find_parent
  end


  def parent_class
    @parent_class ||= @parent.class
  end

  def parent_class= val
    @parent_class = val
  end

  def parent?
    !(%w{NilClass TrueClass FalseClass}.include? parent.class.to_s)
  end

  #
  #
  # return the resources collection - preferably from the cache
  def resources options={}
    @resources ||= find_resources options
  end


  #
  # returns the url for the resource - like /users/1
  def resource_url options={}
    options = resource_options(options)
    action= case params[:action]
      when 'show'; '/%s' % resource.id
      when 'edit'; '/%s/edit' % resource.id
      else ''
      end
    parent? ? ("%s/%s%s%s" % [parent_url,resource_name,action,options]) : ("/%s%s%s" % [resource_name,action,options])
  rescue Exception => e
    scoop_from_error e
  end


  #
  # returns the url for the resources - /employees or /employees/1/events
  def resources_url options={}
    options = resource_options(options)
    r = "%s_path" % resource_name
    d,a,r = send(r).split("/")
    a = a =~ /admin/ ? [ '/',a, parent_url ].join("/") : parent_url
    [ a, r  ].join("/").gsub /\/\//,'/'
  rescue Exception => e
    scoop_from_error e
  end

  #
  # parent_url returns the parent url - /employees/1
  def parent_url options={}
    parent? ? ( "/%s/%s" % [ @parent.class.table_name, @parent.id ] ) : ""
  rescue Exception => e
    scoop_from_error e
  end


  private

    # you can override this on your controller
    def redirect_after_create
      resources_url {}
    end

    # you can override this on your controller
    def redirect_after_update
      resources_url {}
    end

    #
    # print_resources will try to add a print_job
    # return error code
    def print_resources
      if resource_class == PrintJob
        resources.each do |res|
          return NOQUEUE unless Delayed::Job.enqueue res, :queue => 'printing'
        end
        return PRINTSUCCESS
      else
        return NOUSER unless current_user
        params[:user] = current_user
        if params[:print_list].nil?
          #
          # print something specific?
          if params[:print_cmd].nil?
            resources.each do |res|
              return PRINTRECERROR unless res.print_record params: params, context: self
            end
          else
            resources.each do |res|
              return PRINTCMDERROR unless res.send(params[:print_cmd],params)
            end
          end
        else
          params[:resources] = resources
          return PRINTLISTERROR unless resource_class.print_list( params )
        end
      end

      return PRINTSUCCESS


    rescue Exception => err
      return PRINTEXCEPTION
    end

    #
    # use views/../$action.html+mobile.erb if request originates from an iPad
    #
    def set_variant_template
      request.variant = :mobile if request.user_agent =~ /iPad/
    end

    def resource_options options
      options.merge! params.except( "id", "controller", "action" )
      options = (options.empty? ? "" : "?" + options.collect{ |k,v| "#{k}=#{v}" }.join("&"))
    end

    #
    # find the resources collection
    def find_resources options

      # return [] unless resource_class.ancestors.include? ActiveRecord::Base
      params[:ids] ||= []
      params[:ids] << params[:id] unless params[:id].nil?

      if params[:ids].compact.any?
        policy_scope(resource_class).where(id: params[:ids].compact.split(",").flatten)
      else
        if params[:q].blank? #or params[:q]=="undefined"
          r = parent? ? parent.send(resource_name) : (resource_class.nil? ? nil : find_all_resources(options))
        else
          r = find_resources_queried options
        end
        if (r.respond_to?( :page)) && (params[:format].nil? or params[:format]=='html' or params[:scrolling])
          params[:perpage] ||= 20
          params[:page] ||= 1
          return r.page(params[:page]).per(params[:perpage])
        else
          return r
        end

        # (params[:format].nil? or params[:format]=='html') ? r.page(params[:page]).per(params[:perpage]) : r
      end
    end

    #
    # find queried resources collection - implement on each controller to customize
    # raise an exception
    def find_all_resources options
      policy_scope(resource_class)
    end

    #
    # find queried resources collection - implement on each controller to customize
    # raise an exception
    def find_resources_queried options
      case params[:f]
      when nil
        if parent?
          policy_scope(resource_class).tags_included?( params[:q].split(" ") ).where( options )
        else
          policy_scope(resource_class).tags_included?( params[:q].split(" ") )
        end
      else
        policy_scope(resource_class)
      end
    end


    #
    # build options for fixed action button - implement on each controller to customize
    # raise an exception
    def set_fab_button_options
      opt = { items: {}}
      case params[:action]
      when 'nothing'; opt = opt
      # when 'new';   #opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }
      # when 'edit';  #opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }
      # when 'show';  opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print', browser: 'new' }
      # when 'index'; opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }
      end

      # = build_print_link(f.object, list: false, print_options: "print_cmd=print_label", button: 'icon-tag', text: 'Udskriv dæk label')
      @fab_button_options = opt
    end

    #
    #
    # /employees/1/teams
    # /employees/1/teams/5
    # /employees/1/teams/5/attach
    # /theatres/2/contacts/5/uris.js
    def find_parent path=nil, parms=nil
      path ||= request.path
      parms ||= params
      if parms[:parent].nil? #or params[:parent_id].nil?
        paths=path.split("/")
        paths.pop if %w{new edit show create update delete index}.include? paths[-1]
        return nil if (paths.size < 3) #or (paths.size==4 and %w{edit new}.include?( parms[:action]))
        recognise_path paths.join("/")
      else
        parms[:parent].classify.constantize.find(parms[:parent_id])
      end
    end
    #
    # ['theatres','5','contacts','2','uris.js']
    def recognise_path path
      path_elements = Rails.application.routes.recognize_path path.gsub /\..*$/,''   # "/admin/users/2/printers/3/attach" => {:controller=>"printers", :action=>"attach", :user_id=>"2", :id=>"3"}
      recognise_parent( recognise_resource( path_elements ) )

    rescue Exception => e
      nil
      # return [ nil, nil, false ] if e.class.to_s == "ActionController::RoutingError"

    end

    # {:controller=>"printers", :action=>"attach", :user_id=>"2", :id=>"3"}
    def recognise_resource elems
      resource_class = elems.delete(:controller).singularize.classify.constantize
      resource = resource_class.find( elems.delete(:id) )
      elems
    rescue Exception => e
      return elems if e.class.to_s == "ActiveRecord::RecordNotFound"
      resource_class = nil
      elems
    end

    # { :action=>"attach", :user_id=>"2" }
    def recognise_parent elems
      elems.delete :action
      arr = elems.keys.first.to_s.split("_")
      return nil unless arr.include? "id"
      arr.pop
      arr.join("_").singularize.classify.constantize.find(elems.values.first)
    rescue
      nil
    end

    #
    # # /employees/1/teams/new
    # # /employees/1/teams/1/edit
    # # /employees/1/teams/1/delete
    def update_parenthood
      if params[:parent] and params[:parent_id]
        # raise "Ups - is this ready for prime time yet?"
        parent = params[:parent].classify.constantize.find(params[:parent_id])
        unless parent.blank?
          case params[:action]
          when "create"
            children = eval("parent.#{resource_name}")
            children << resource unless children.include? resource
          # when "edit"
          when "delete"
            children = eval("parent.#{resource_name}")
            children >> resource
          end
        end
      end
      true
    rescue
      false
    end
    #
    #

    def scoop_from_error e
      raise e if Rails.env=='development'
      logger.debug "AbstractResourcesController##{params[:action]}: #{e.class}"
      a_url = root_path

      case e.class.to_s
      when "Exceptions::AuthenticationError"
        flash.now[:error] = flash[:error] = "Access Problem: <br/><small>%s</small>" % e.message
        result= false
        status = 412

      when "ActiveRecord::RecordNotFound"
        flash.now[:error] = flash[:error] = t('.fail.record_not_found')
        result = false
        status = 301
        a_url = resources_url

      when "Pundit::NotAuthorizedError"
        flash.now[:error] = flash[:error] = t('.fail.authorized', resource: resource)
        result = false
        status = 401

      when "ActiveRecord::StatementInvalid" # Mysql2::Error
        flash.now[:error] = flash[:error] = t('fail.mysql_error', mysql: e.to_s)
        result= false
        status = 409
      when "ActionView::Template::Error"
        flash.now[:error] = flash[:error] = "A template error occured - please call ALCO with: <br/><small>%s</small>" % e.message
        result= false
        status = 301
      else
        raise e
        # flash.now[:error] = flash[:error] = "An error occured - please refer to log for details!"
        # render :error, layout: false, status: 412 and return
      end

      respond_to do |format|
        case params[:action]
        when 'new'
          format.html { flash.keep(:error) ; redirect_to resources_url }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resources, status: status }
        when 'create'
          format.html { render :new }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resource.errors, status: status }
        when 'show'
          format.html { flash.keep(:error) ; redirect_to resources_url }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resources, status: status }
        when 'edit'
          format.html { flash.keep(:error) ; redirect_to resources_url }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resources, status: status }
        when 'update'
          format.html { render :edit }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resource.errors, status: status }
        when 'index', 'destroy'
          # we should render index - but an error here will not make us happy
          # format.html { render :index }
          #
          format.html { redirect_to root_path, alert: flash[:error] }
          format.js   { render :error, layout: false, status: status, locals: { result: result} }
          format.json { render json: resources, status: status }
        else
          format.html { redirect_to a_url and return }
          format.js   { render :error, layout:false, status: status, locals: { result: result } }
        end
      end

    end

end