class AssetsController < ApplicationController
  before_action :require_system_admin_role, only: [:edit]
  before_action :set_asset, only: [:show, :edit, :relatives, :update, :destroy]
  before_action :set_client_schedule_rates, only: [:new, :edit]
  before_action :set_variant, only: [:edit, :update, :edit_multiple, :edit_multiple_asset_load]
  before_action :set_sam_id, only: [:create, :update, :nearby, :edit_multiple, :edit_multiple_asset_load]
  before_action :set_schedules, only: [:show, :edit]
  before_action :set_paper_trail_whodunnit
  after_filter { flash.discard if request.xhr? }

  def index
    if current_user.is_subcontractor?
      @assets = Asset.assigned_to_subcontractor(current_user)
    else
      @assets = Asset.all
    end
  end

  def show
  end

  def edit
    set_schedule_rates
  end

  def relatives
  end

  def create
    @asset = Asset.new(asset_params)

    if @asset.save
      @client_schedule_rates = ClientScheduleRate.by_project(@asset.project.id)
      @subcontractor_schedule_rates = SubcontractorScheduleRate.by_project(@asset.project.id)
      set_schedules

      flash[:success] = "Asset was created successfully"
    else
      @client_schedule_rates = ClientScheduleRate.all
      @subcontractor_schedule_rates = SubcontractorScheduleRate.all

      flash[:alert] = "Asset failed to create"
    end

    respond_to do |format|
      format.html {
        if params[:multiple] == "true"
          @assets = [@asset]
          @multiple = true
          render partial: 'form'
        else
          render :edit
        end
      }
    end
  end

  def update
    @asset.update_from_params(update_params, variation_permitted: policy('maps_progress').manage?)
    @asset.reload
    @client_schedule_rates = ClientScheduleRate.by_project(@asset.project)
    @subcontractor_schedule_rates = SubcontractorScheduleRate.by_project(@asset.project)
    set_schedules

    if @asset.errors.empty?
      flash[:success] = "Asset was successfully saved"
      @unassigned = set_unassigned(@asset)
    else
      flash[:alert] = "Asset failed to save"
    end

    respond_to do |format|
      format.html do
        if params[:multiple] == "true"
          @assets = [@asset]
          @multiple = true
          render partial: 'form'
        else
          render :show
        end
      end
    end
  end

  def destroy
    @asset.destroy
    respond_to do |format|
      format.html { redirect_to assets_url, notice: 'Asset was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  def nearby
    @multiple = true
    codes = params[:asset_codes]
    @assets = Asset.where(code: codes)
    @non_assets = build_new_assets_from(codes)
    @num_assets = @assets.count
    @num_non_assets = @non_assets.count
    @asset = first_asset_from(codes) if asset_entities.present?

    respond_to do |format|
      format.html { render partial: 'nearby' }
      format.js { render partial: 'nearby' }
    end
  end

  def edit_multiple
    @multiple = true
    codes = params[:asset_codes]

    @assets = Asset.includes(asset_client_schedules: [:client_schedule_rate, :asset_subcontractor_schedules]).where(code: codes).to_a

    @non_assets = build_new_assets_from(codes)

    @num_assets = @assets.count
    @num_non_assets = @non_assets.count

    # move first asset to the top of the list
    to_delete = @assets.select {|a| a["code"] == codes[0] }.first()
    if (to_delete)
      @assets.delete_if { |a| a["code"] == codes[0] }
      @assets.unshift(to_delete) if (to_delete)
    end

    @asset = first_asset_from(codes) if asset_entities.present?
    @unassigned = set_unassigned(@asset)
    set_schedule_rates

    set_schedules

    respond_to do |format|
      format.html { render partial: 'edit_multiple' }
      format.js { render partial: 'edit_multiple' }
    end
  end

  def edit_multiple_asset_load
    #TODO there
    @multiple = true
    if params[:is_new] == 'false'
      @asset = Asset.all
        .includes(progress_entries: [:progress_line_items, :images, :progress_resource_items])
        .includes(asset_client_schedules: [:progress_line_items, :variation_line_items])
        .includes(asset_subcontractor_schedules: [:progress_line_items, :defects, :variation_line_items])
        .includes(:asset_notes)
        .includes(:asset_access)
        .includes(defects: :images)
        .includes(variations: [:variation_line_items, :images])
        .includes(:ifdvs).where(code: params[:asset_code]).first
    else
      @asset = Asset.new
      @asset.code = params[:asset_code]
    end

    @unassigned = set_unassigned(@asset)
    set_schedule_rates
    set_schedules

    respond_to do |format|
      format.js { render partial: 'form' }
    end
  end

  def filter_assets
    unassigned_select = params[:unassigned_select]
    if (params[:fda_id] && !params[:fda_id].empty?)
      @assets = Asset.where(fda_id: params[:fda_id]).includes(:asset_client_schedules)
    elsif (params[:sam_id] && !params[:sam_id].empty?)
      @assets = Asset.joins(:fda).where(fdas: { sam_id: params[:sam_id]}).includes(:asset_client_schedules)
    else
      @assets = Asset.all.includes(:asset_client_schedules)
    end

    case unassigned_select
      # all - 0 - do nothing
      # unassigned
      when '1'
        @assets = @assets.reject {|a| a.asset_client_schedules.any?}
        #@assets = @assets.joins("LEFT OUTER JOIN asset_client_schedules ON assets.id = asset_client_schedules.asset_id")
        #              .where("asset_client_schedules.asset_id is null")
      # assigned
      when '2'
        @assets = @assets.reject {|a| !a.asset_client_schedules.any?}
        #@assets = @assets.joins("LEFT OUTER JOIN asset_client_schedules ON assets.id = asset_client_schedules.asset_id")
        #              .where("asset_client_schedules.asset_id is not null")
    end
    respond_to do |format|
      format.js
    end
  end

  def paginated_assets
    if params[:sam_id].present?
      query = Asset.joins(:fda).where(fdas: { sam_id: params[:sam_id] })
    else
      query = Asset.joins(:fda)
    end
    query = query.where("lower(assets.code) like ?", "%#{params[:term].downcase}%") if params[:term].present?
    query = query.where(fda_id: params[:fda_id]) if params[:fda_id].present?

    if params[:unassigned_select].present?
      query = query.joins("LEFT OUTER JOIN asset_client_schedules ON assets.id = asset_client_schedules.asset_id")
      case params[:unassigned_select]
        when '1'
          query = query.where(asset_client_schedules: { asset_id: nil })
        when '2'
          query = query.where.not(asset_client_schedules: { asset_id: nil })
          query = query.assigned_to_subcontractor(current_user) if current_user.is_a_subcontractor?
      end
    end
    query = query.uniq
    total_count = query.size
    query = query.page(params[:page]).per(50)

    render json: { total_count: total_count, items: query.map{ |a| { id: a.code, code: a.code } } }
  end

  private

  def set_asset
    @asset = Asset.find(params[:id])
  end

  def set_asset_by_asset_id_param
    @asset = Asset.find(params[:asset_id])
  end

  def set_client_schedule_rates
    @client_schedule_rates = ClientScheduleRate.all
  end

  def set_variant
    request.variant = :subcontractor if current_user.is_a_subcontractor?
  end

  def asset_params
    params.require(:asset).permit(:code, :description, :fda_id, :parent_id, :asset_class_id, :asset_configuration_id, :asset_status_id,
                                  :asset_client_schedules_attributes => [:id, :client_schedule_rate_id, :quantity, :_destroy],
                                  :asset_subcontractor_schedules_attributes => [:id, :subcontractor_schedule_rate_id, :quantity, :subcontractor_id, :start_coord, :end_coord, :discard, :changed_from, :_destroy],
                                  notes_attributes: [:id, :note, :note_type_id, :_destroy,
                                    images_attributes: [:id, :file, :description, :_destroy]],
                                  progress_entries_attributes: [:id, :date, :note, :_destroy, progress_line_items_attributes: [:id, :progressable_id, :progressable_type, :quantity, :actual_quantity, :_destroy],
                                    images_attributes: [:id, :file, :description, :_destroy], progress_resource_items_attributes: [:id, :resource_id, :quantity, :number_of, :_destroy]],
                                  defects_attributes: [:id, :defect_date, :asset_subcontractor_schedule_id, :defect_type_id, :defect_code_id, :defect_severity_id, :description, :rectification_required, :captured_by, :supporting_info, :comments, :target_rectification_date, :defect_status_id, :completion_date, :_destroy,
                                    images_attributes: [:id, :file, :description, :_destroy]],
                                  variations_attributes: [:id, :_destroy],
                                  ifdvs_attributes: [:id, :_destroy],
                                  asset_access_attributes: [:id, :asset_id, :requested_at, :approved_at, :on_hold, :spec_instructions, :_destroy],
                                  parameters_attributes: [:id, :key, :value, :_destroy],
                                  children_attributes: [:id, :asset_status_id]
    )
  end

  def update_params
    sam_status = @asset.sam.sam_status

    a = []

    if policy('maps_asset_details').manage?
      a += [
        :code, :description, :fda_id, :parent_id, :asset_class_id,
        :asset_configuration_id
      ]
    end

    if policy('maps_asset_status').manage?
      a += [
        :asset_status_id,
        children_attributes: [:id, :asset_status_id]
      ]
    end

    if policy('maps_parameters').manage?
      a += [
        parameters_attributes: [:id, :key, :value, :_destroy]
      ]
    end

    if policy('maps_client_schedule_of_rates').manage? or policy('maps_subcontractor_schedule_of_rates').manage? or (sam_status.present? and sam_status.lock_schedules?)
      a += [asset_client_schedules_attributes: [:id, :client_schedule_rate_id, :quantity, :_destroy, asset_subcontractor_schedules_attributes:
           [:id, :subcontractor_schedule_rate_id, :quantity, :subcontractor_id, :start_coord, :end_coord, :created_by_variation, :variation_id, :asset_id, :discard, :changed_from, :_destroy]],
           asset_subcontractor_schedules_attributes: [:id, :subcontractor_schedule_rate_id, :quantity, :subcontractor_id, :start_coord, :end_coord, :created_by_variation, :variation_id, :asset_id, :discard, :changed_from, :_destroy]]
    end

    if policy('maps_progress').manage? or (sam_status.present? and sam_status.lock_progress?)
      a += [
        progress_entries_attributes: [
          :id, :date, :note, :_destroy, progress_line_items_attributes: [
            :id, :progressable_id, :progressable_type, :quantity, :actual_quantity,
            :finished_type, :variation_reason, :_destroy], images_attributes: [
              :id, :file, :description, :_destroy],
               progress_resource_items_attributes: [
                :id, :resource_id, :quantity, :resource_type_id, :_destroy
              ]
            ]
          ]
    end

    if policy('maps_quality_checks').manage?
      a += [
        defects_attributes: [:id, :defect_date, :asset_subcontractor_schedule_id,
          :defect_type_id, :defect_code_id, :defect_severity_id, :description,
          :rectification_required, :captured_by, :supporting_info, :comments,
          :target_rectification_date, :defect_status_id, :completion_date,
          :_destroy, images_attributes: [:id, :file, :description, :_destroy]
        ]
      ]
    end

    if policy('maps_variations').manage? or (sam_status.nil? and sam_status.lock_variations?)
      a += [variations_attributes: [:id, :_destroy]]
    end

    if policy('maps_ifdvs').manage?
      a += [ifdvs_attributes: [:id, :_destroy]]
    end

    if policy('maps_notes').manage?
      a += [
        notes_attributes: [
          :id, :note, :note_type_id, :_destroy,
          images_attributes: [:id, :file, :description, :_destroy]]
        ]
    end

    if policy('maps_land_access').manage?
      a += [
        asset_access_attributes: [
          :id, :requested_at, :approved_at, :on_hold, :spec_instructions, :_destroy
        ]
      ]
    end
    params.require(:asset).permit(a)
  end

  def asset_multiple_params
    params.require(:asset_codes[])
  end

  def set_unassigned(asset)
    return if !asset || asset.new_record?
    asset.asset_subcontractor_schedules.where(subcontractor_id: nil)
  end

  def build_new_assets_from codes
    (codes - @assets.map(&:code)).map { |code| Asset.new(code: code) }
  end

  def first_asset_from codes
    asset_entities.find { |asset| asset.code == codes.first }
  end

  def asset_entities
    @assets + @non_assets
  end

  def set_schedule_rates
    if @asset.persisted? || @sam_id.present?
      project = @asset.project || Sam.find(@sam_id).project
      @client_schedule_rates = ClientScheduleRate.by_project(project.id)
      @subcontractor_schedule_rates = SubcontractorScheduleRate.by_project(project.id)
    else
      @client_schedule_rates = ClientScheduleRate.all
      @subcontractor_schedule_rates = SubcontractorScheduleRate.all
    end
  end

  def set_sam_id
    @sam_id = params[:sam_id]
  end

  def set_schedules
    @asset_client_schedules = policy_scope @asset.asset_client_schedules
    @unassociated_subcontractor_schedules = policy_scope @asset.subcontractor_schedules_unassociated
  end

  def require_system_admin_role
    permission_denied unless request.xhr? || current_user.is_system_admin?
  end
end