class RequestToProvidersController < ApplicationController

  def index
    u = current_user
    @request_to_providers = u.request_to_providers.order('created_at desc')
    render layout: false
  end

  def show
    request = current_user.request_to_providers.find(params[:id].to_i)
    if request
      @provider_response_to_request = request.provider_responses_to_request.paginate(page: (params[:page] || 1).to_i,
                                                                                     per_page: params[:per_page])
    end
    render layout: false
  end

  def new
    @request_to_providers = RequestToProvider.new
    render layout: false
  end

  def edit
    @request_to_provider = RequestToProvider.find(params[:id].to_i)
    @img_nb = Reqphoto.where(request_to_provider_id: @request_to_provider.id).count
    prov_id = SelectedProvidersForRequest.find_by_request_to_provider_id(@request_to_provider.id).provider_id
    imgs = []
    @img = {}
    unless @img_nb == 0
      Reqphoto.where(request_to_provider_id: params[:id]).collect{|rtp| imgs << rtp.reqphoto_file_name}
      @img = Image.where(original_filename: imgs, provider_id: prov_id)
    end
    @login = User.find(@request_to_provider.user_id).login
    render layout: 'adm_agency'
  end

  def create
    u = current_user
    provs = []
    if params[:providers].nil?
      provs = session[:provs]
    else
      provs = params[:providers].keys
    end

    serial = gen_serial(u)
    serial = gen_serial(u) while !RequestToProvider.find_by_serial(serial).nil?

    attached_file = ''
    original_file_name = ''
    unless params[:attached_file].blank?
      uploaded_file = params[:attached_file]
      original_file_name = uploaded_file.original_filename
      original_file_extension = File.extname(original_file_name)
      # multiple files managment
      #uploaded_list.each do |list|
      file_name = "request_#{serial}_attachment#{original_file_extension}"
      attached_file = Rails.root.join('public','uploads',file_name)
      File.open(attached_file,'wb') do |f|
        f.write(uploaded_file.read)
      end
    end

    request = RequestToProvider.new( text: params[:text], user_id: u.id, serial: serial )
    if request.save
      provs_sk = []
      provs.each do |provider_id|
        provs_sk << Provider.find(provider_id).string_key
        request.selected_providers_for_requests.create(provider_id: provider_id)
      end
      parameters = { user_text: params[:text], file_path: attached_file, original_file_name: original_file_name, file_url: params[:file_url], serial: serial, string_key: provs_sk }
      api_call("user_request", u.login, 0, parameters)
      flash[:notice] = I18n.t('request_succeed')
    else
      flash[:notice] = I18n.t('action_failed')
    end
    @request_to_providers = u.request_to_providers
    redirect_to action: 'index'
  end

  def update
    @request_to_provider = RequestToProvider.find(params[:id])
    folder = @request_to_provider.serial
    provs = []
    session[:provhd].each_with_index{|v,i| provs << i if v == 1}
    prov = Provider.joins(:selected_providers_for_requests).where(selected_providers_for_requests:{request_to_provider_id:@request_to_provider.id},providers:{id: provs}).first.string_key
    config_db_ms = Rails.configuration.database_configuration['ms_db']
    client = Mysql2::Client.new(:host => config_db_ms["host"],:database => config_db_ms["database"],:username => config_db_ms["username"], :password => config_db_ms["password"])
    #check if agency has an internal stock
    row_add_prefix =  client.query("SELECT aap_agency_id from AgencyAdditionalPrefix where AgencyAdditionalPrefix.aap_prefix='#{prov}'")
    if row_add_prefix.count > 0
      agency_id = row_add_prefix.first['aap_agency_id']
      row =  client.query("SELECT inDir_path FROM InputDirectories where InputDirectories.inDir_agencyId=#{agency_id} and inDir_type = 1 limit 1")
    else
      row =  client.query("SELECT inDir_path FROM InputDirectories LEFT JOIN Agences on Agences.id=InputDirectories.inDir_agencyId where Agences.filePrefix='#{prov}' and inDir_type = 1 limit 1")
    end
    inDir = row.first["inDir_path"]
    client.close

    inDir.gsub!("/usr/PPserver/in/","")
    ftp_config = YAML.load_file(File.join(Rails.root, 'config', 'ftp.yml'))
    ftp = Net::FTP.new(ftp_config[:ms][:host],ftp_config[:ms][:in_access][:user], ftp_config[:ms][:in_access][:passwd])
    ftp.passive = ftp_config[:ms][:passive]
    ftp.chdir(inDir)
    begin
      ftp.chdir(folder)
    rescue Net::FTPPermError
      ftp.mkdir(folder)
      ftp.chdir(folder)
    end

    unless params[:rphoto].blank?
      params[:rphoto].each do |photo|
        File.open("/tmp/#{photo.original_filename}", "wb") do |file|
          file.write(photo.read)
          ftp.putbinaryfile(file)
        end
        reqphoto = Reqphoto.new(reqphoto_file_name: photo.original_filename, request_to_provider_id: @request_to_provider.id)
        reqphoto.save
      end
    end
    ftp.close
    redirect_to rtp_path
  end

  def destroy
    RequestToProvider.find(params[:id].to_i).destroy
    redirect_to  :back, notice: "Requete supprimée"
    #modif Patrick : voir si retour index au lieu de back
    #redirect_to 'index', notice: "Requete supprimée"

  end

  private

  def gen_serial(user)
    title = simplifize(user.title.name)
    server = user.title.server.name
    serial = "#{title}_#{server}_"
    5.times do
      rnd = rand(52)
      serial += (rnd > 25) ? rand(10).to_s : (65+rnd).chr
    end
    serial
  end

end