class PatientsController < ApplicationController
  layout  'patient'
  before_filter :set_visit_id, :except => :checkin

  def index
    # Use this to do the superfast AJAX autocomplete
    begin
      @patients = Patient.find_all_by_practice_id(session[:practice_id], :select => 'id, search_helper,first_name',:order=>'first_name')
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  #OBSERVE_FIELD for the responsible party name
  def search_responsible_party
    conditions_string = "practice_id = ? "
    conditions_array = []
    conditions_array.<< session[:practice_id]

    if (!params[:first_name].empty?)
      conditions_string += " AND first_name LIKE ? "
      conditions_array.<< params[:first_name] + "%"
    end

    if (!params[:middle_name].empty?)
        conditions_string += " AND middle_name LIKE ? "
        conditions_array.<< params[:middle_name] + "%"
    end

    if (!params[:last_name].empty?)
        conditions_string += " AND last_name LIKE ? "
        conditions_array.<< params[:last_name] + "%"
    end

    begin
      @responsible_party = ResponsibleParty.find :all, :conditions => [conditions_string] + conditions_array
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def fill_responsible_party
    begin
      if params[:id] != ""
        @responsible = ResponsibleParty.find(params[:id])
        render :partial=>'responsible_party_auto_fill'
      else
        render :text=>'<font color=red>Responsible Party Not Found.</font>'
      end
    rescue => e
     render :text=> " #{e.message}"
    end
  end

  def find
    begin
      @patient = Patient.identify(params[:patient], session[:practice_id])
      if (@patient)
        redirect_to(:action=>"show", :id=>@patient.id)
      else
        flash[:error] = "Could not find patient. Please try again..."
        redirect_to(:action=>:index)
      end
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def search_patient
    if params[:search_by] == "first_name"
      @patient_result = Patient.find(:all,:conditions=>["first_name like ? and practice_id =? ", params[:id] +"%",session[:practice_id]])
    elsif params[:search_by] == "last_name"
      @patient_result = Patient.find(:all,:conditions=>["last_name like ? and practice_id =?", params[:id] +"%",session[:practice_id]])
    else
       @patient_result = Patient.find(:all,:conditions=>["first_name like ? or last_name like ? and practice_id =?", params[:id] +"%",params[:id] +"%",session[:practice_id]])
    end
    @no_of_record= @patient_result.length
    paging
    if @patient_result == []
       render :text=>'<font color=red>No Record Found</font>'
    else
       render :partial=>'patient_result'
    end
  end
  def new
    begin
      @carriers = Carrier.find_all_by_practice_id(session[:practice_id]).map {|u| [u.name, u.id]}
      @patient = Patient.new
      @responsible_party = ResponsibleParty.new
      @policy = Policy.new
      @referal_provider = @patient.referal_providers.new
      @doctors = Doctor.find_all_by_practice_id(session[:practice_id],:include=>"user",:select=>["id,first_name,last_name"])
      render(:layout => 'new_patient', :action => 'account')
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def show
    # Here again, we search within the practice to avoid hack attacks
    begin
      @patient = Patient.find(params[:id], :include => :policies)
      @patient.set_amounts_due
      @record = @patient.most_recent_record
      @responsible_party = @patient.responsible_party
      @referal_provider = @patient.referal_providers.first
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def create
    begin
      @carriers = Carrier.find_all_by_practice_id(session[:practice_id]).map {|u| [u.name, u.id]}
      @practice = Practice.find(session[:practice_id])

      Patient.transaction do
        @patient = Patient.new(params[:patient])
        @patient.practice_id = @practice.id
        @patient.doctor_id = Doctor.find_by_user_id(session[:user]) if params[:patient][:doctor_id] ==  ""
        @patient.dob = Patient.date_split(params[:patient][:dob])
        if params[:self] == "new"
          @patient.responsible_party = ResponsibleParty.new(params[:responsible_party])
          @patient.responsible_party.practice_id = session[:practice_id]
        elsif params[:self] == "auto_complete"
          responsible = ResponsibleParty.find(params[:responsible_party_id])
          @patient.responsible_party_id = responsible.id
       elsif params[:self] == "self"
          @patient.responsible_party = ResponsibleParty.create(:first_name => params[:patient][:first_name],
                                             :middle_name=>params[:patient][:middle_name],
                                             :last_name => params[:patient][:last_name],
                                             :address => params[:patient][:address],
                                             :apt_suite=> params[:patient][:apt_suite],
                                             :address_line1=> params[:patient][:address_line1],
                                             :city=> params[:patient][:city],
                                             :state=> params[:patient][:state],
                                             :zipcode=> params[:patient][:zipcode],
                                             :email=> params[:patient][:email],
                                             :home_phone=> params[:patient][:primary_phone],
                                             :work_phone=> params[:patient][:alternate_phone],
                                             :cell_phone=> params[:patient][:cell_phone],
                                             :practice_id=>session[:practice_id])
       end

        if(params[:referal_provider][:first_name] != "")

          @referal_provider = ReferalProvider.new(params[:referal_provider])
          @referal_provider.practice_id = @practice.id
          @referal_provider.save
          @patient.referals.create(:patient_id => @patient.id,
                                  :referal_provider_id => @referal_provider.id,
                                  :creation_date => Time.now )
        end
        if !(params[:policy][:carrier_id] == "Select")
          @patient.policies.create(:patient_id => @patient.id,
                                  :start_at => Patient.date_split(params[:policy][:start_at ]),
                                  :end_at => Patient.date_split(params[:policy][:end_at]),
                                  :carrier_id =>params[:policy][:carrier_id],
                                  :relationship_id => params[:policy][:relationship_id],
                                  :group_number => params[:policy][:group_number],
                                  :group_name => params[:policy][:group_name],
                                  :copay => params[:policy][:copay],
                                  :copay_type => params[:policy][:copay_type],
                                  :subscriber_first_name => params[:policy][:subscriber_first_name],
                                  :subscriber_last_name => params[:policy][:subscriber_last_name],
                                  :subscriber_apt_suite =>params[:policy][:subscriber_apt_suite],
                                  :subscriber_address_line1 => params[:policy][:subscriber_address_line1],
                                  :subscriber_address=> params[:policy][:subscriber_address],
                                  :subscriber_city => params[:policy][:subscriber_city],
                                  :subscriber_state => params[:policy][:subscriber_state],
                                  :subscriber_zipcode =>params[:policy][:subscriber_zipcode],
                                  :subscriber_DOB => Patient.date_split(params[:policy][:dob]),
                                  :subscriber_sex => params[:policy][:subscriber_sex],
                                  :subscriber_status => params[:policy][:subscriber_status],
                                  :subscriber_number => params[:policy][:subscriber_number],
                                  :subscriber_employer => params[:policy][:subscriber_employer],
                                  :carrier_type => "Primary")
        end
        if !(params[:policy][:carrier_id_sec] == "Select")
         @patient.policies.create(:patient_id => @patient.id,
                                  :start_at => Patient.date_split(params[:policy][:start_at_sec]),
                                  :end_at => Patient.date_split(params[:policy][:end_at_sec]),
                                  :carrier_id => params[:policy][:carrier_id_sec],
                                  :relationship_id => params[:policy][:relationship_id_sec],
                                  :group_number => params[:group_number_sec],
                                  :group_name => params[:group_name_sec],
                                  :copay => params[:policy][:copay_sec],
                                  :copay_type => params[:policy][:copay_type_sec],
                                  :subscriber_first_name => params[:subscriber_first_name_sec],
                                  :subscriber_last_name => params[:subscriber_last_name_sec],
                                  :subscriber_apt_suite =>params[:policy][:subscriber_apt_suite_sec],
                                  :subscriber_address_line1 => params[:subscriber_address_line1_sec],
                                  :subscriber_address=> params[:subscriber_address_sec],
                                  :subscriber_city => params[:subscriber_city_sec],
                                  :subscriber_state => params[:policy][:subscriber_state_sec],
                                  :subscriber_zipcode =>params[:subscriber_zipcode_sec],
                                  :subscriber_DOB => Patient.date_split(params[:policy][:dob_sec]),
                                  :subscriber_sex => params[:policy][:subscriber_sex_sec],
                                  :subscriber_status => params[:subscriber_status_sec],
                                  :subscriber_number => params[:subscriber_number_sec],
                                  :subscriber_employer => params[:subscriber_employer_sec],
                                  :carrier_type => "Secondary")
        end
        if @patient.save
          redirect_to(:controller => 'patients' ,:action => 'show', :id => @patient.id)
        else
          logger.debug(@patient.errors.full_messages)
          redirect_to :back
        end
      end
    rescue => e
      render :text=> " #{e.message}"
   end
  end

  # editing the patient information
   def payments_notes_edit
    begin
      @patient = Patient.find(params[:id])
      @patient.update_attributes(params[:patient])
       rescue => e
      render :text=> " #{e.message}"
     end
     render :partial=>"payment_notes"
   end

   def payments_notes
     @patient = Patient.find(params[:id])
     render :partial=>"payment_notes"
   end

   def payments_edit_notes
     @patient = Patient.find(params[:id])
     render :partial=>"payment_notes_edit"
   end

  def edit_account_info
    begin
      @patient = Patient.find(params[:id])
      dob = Patient.date_split(params[:patient][:dob])
      @patient.update_attributes(params[:patient])
      @patient.update_attributes(:dob=>dob)
   rescue => e
      render :text=> " #{e.message}"
    end
  end

  #editing patient quick notes and medical history
  def edit_notes
    begin
      @patient = Patient.find(params[:id])
      @patient.update_attributes(params[:patient])
       rescue => e
      render :text=> " #{e.message}"
     end
    end

  def referal_edit
     @referal_provider = ReferalProvider.find(params[:id])
     render :partial=>'referals/referal_info_edit'
  end

  def cancel_referal_edit
     @referal_provider = ReferalProvider.find(params[:id])
     render :partial=>'referals/details'
  end

  #edit responsible party
  def edit_responsible_party
    begin
      @patient = Patient.find(params[:id])
      @responsible_party= @patient.responsible_party
      @responsible_parties = ResponsibleParty.find_all_by_practice_id(session[:practice_id])
      @responsible_party.update_attributes(params[:responsible_party])
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  #new referal
  def new_referal
   if request.method == :get
      render :partial=> 'referals/new_referal'
   else
      @patient = Patient.find(params[:id])
      @referal_provider = ReferalProvider.new(params[:referal_provider])
      @referal_provider.practice_id= @patient.practice_id
      @referal_provider.save
      @patient.referals.create(:patient_id => @patient.id,:referal_provider_id => @referal_provider.id,:creation_date => Time.now )
      render :partial=>"referals/details"
   end
  end

  #edit the referal provider information
  def edit_referal
    begin
      @referal_provider = ReferalProvider.find(params[:id])
      @referal_provider.update_attributes(params[:referal_provider])
#      @patient = Patient.find(params[:patient_id])
    rescue => e
      render :text=> " #{e.message}"
    end
      render :partial=>'referals/details'
  end


  def notes_edit
     @patient = Patient.find(params[:id])
     render :partial=>'notes_edit'
  end

  def notes_cancel
     @patient = Patient.find(params[:id])
      render :partial=>'notes'
    end

  def account_edit
     @patient = Patient.find(params[:id])
      render :partial=>'account_info_edit'
    end


  def cancel_edit
     if params[:error_flag]
       @claim = Claim.find(params[:claim_id])
       @error_flag = params[:error_flag]
       @patient = Claim.patientdetail(@claim.visit_id,params[:claim_id]).first
       render :partial=>'/claims/claim_edit_patient_detail'
     else
        @patient = Patient.find(params[:id])
        render :partial=>'account_info'
     end
  end


  def responsible_edit
      @patient= Patient.find(params[:id])
      @responsible_party= @patient.responsible_party
      render :partial=>'/responsible_parties/responsible_info_edit'
    end

   def cancel_responsible_edit
      @patient= Patient.find(params[:id])
      @responsible_party= @patient.responsible_party
      render :partial=>'/responsible_parties/details'
    end


  # Record a Visit
  def checkin
    @visit = Visit.todays_visit(params[:id])
    if (@visit.nil?)
      @patient = Patient.find(params[:id])
      policy = Policy.find_by_patient_id_and_carrier_type(@patient.id,'Primary')
      visit = Visit.new
      if (not policy.nil?)
        if policy.copay_type == 'Absolute'
          visit.patient_portion, = policy.copay
          visit.patient_due = policy.copay
          visit.charge = policy.copay
        end
      end
      visit.treated_at = Time.now
      visit.practice_id = session[:practice_id]
      visit.patient_id  = @patient.id
      visit.location_id = session[:location_id]
      visit.doctor_id = @patient.doctor_id
      appointment = Appointment.find_by_patient_id_and_date(@patient.id, Date.today)
      if (appointment)
        appointment.checked_in = true
        appointment.save
        visit.appointment_id = appointment.id
      end
      visit.save
      if (not policy.nil?)
        referal =  Referal.find_by_patient_id(@patient.id)
        referal_provider_id = referal.nil? ? 0 : referal.referal_provider_id

        practice = visit.practice
        practice.claims.create(:visit_id=>visit.id,
                     :policy_id => policy.id,
                     :referal_provider_id=> referal_provider_id,
                     :status=>'PENDING_CHARGE_REVIEW'
                     )
      end
      flash[:message] = "Patient visit recorded for today."
    else
      flash[:error] = "Visit already recorded for today."
      logger.debug("Visit already recorded for today")
    end
    redirect_to :action => 'show',:id=>params[:id]
 end

 def checkout
    begin
      @visit = Visit.todays_visit(params[:id])
      flag = true
      if params[:type] == 'new_visit'
        if @visit.nil?
          flag = false
        end
      else
        flag = true
      end
      if flag
        @patient = @visit ? @visit.patient : Patient.find(params[:id])
        @copay   = Copay.new
        patients = Patient.find_all_by_responsible_party_id(@patient.responsible_party_id,:select=>'id')
        @patient_due = Visit.sum(:patient_due,:conditions=>["patient_id in (?)", patients])
        @selected_procedure_codes = Patient.selected_procedure_codes(@visit.id) if @visit
        @selected_diagnosis_codes = Patient.selected_diagnosis_codes(@visit.id) if @visit
        @visits = Visit.find(:all,:conditions=>["practice_id =? and patient_id in(?) and patient_due > 0",session[:practice_id],patients])
      else
        flash[:error] = "No Visit recorded for today."
        logger.debug("No Visit recorded for today")
        redirect_to :action=>'show',:id=>params[:id]
      end
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def savecopay
    begin
      @visit = Visit.todays_visit(params[:patient_id]) if params[:patient_id] != '0'
      payment = Practice.find(session[:practice_id]).patient_payments.create(:amount=>params[:copay][:paid],
                                  :check_number=>params[:copay][:check_number]
                                  )
      payment.responsible_party_id =  params[:patient_id] != '0' ? @visit ? @visit.patient.responsible_party_id : Patient.find(params[:patient_id]).responsible_party_id : params[:payment][:responsible_party_id]
      payment.received_at = Time.now
     if params[:copay][:check_number].empty?
        payment.payment_method = "Cash"
      else
        payment.payment_method = "Check"
      end
      if payment.save
        #due for the patient for this visit
        if params[:patient_id] != '0'
          patients = Patient.find_all_by_responsible_party_id(@visit? @visit.patient.responsible_party_id : Patient.find(params[:patient_id]).responsible_party_id,:select=>'id')
          @visits = Visit.find(:all,:conditions=>["practice_id =? and patient_id in(?) and patient_due > 0",session[:practice_id],patients])
        else
          patient = Patient.find_all_by_responsible_party_id(params[:payment][:responsible_party_id],:select=>'id')
          @visits = Visit.find(:all,:conditions=>["practice_id =? and patient_due > 0 and patient_id in (?)",session[:practice_id],patient])
        end
        for visit in @visits
          patient_due = visit.patient_due
          temp = "amt_"+ visit.id.to_s
          amount = params[temp].to_f
          if amount > 0
            due = patient_due.to_f - amount
            PaymentVisit.create(:payment_id=>payment.id,:visit_id=>visit.id,:amount=>amount)
            #updating the patient due in visits
            visit.update_attributes(:patient_due=> due)
          end
        end
        if params[:patient_id] != '0'
          redirect_to(:action=>"show", :id=>params[:id])
        else
          redirect_to :controller=>'payment',:action=>'post_payments',:id=>'rp_payment'
        end
      else
       flash[:error] = "Could not save patient checkout information"
       redirect_to(:action=>'checkout',:id=>params[:patient_id])
      end
   rescue => e
      render :text=> " #{e.message}"
    end
  end

  ######################################################################################################
  #  action used to collect the object for the join table and redirecting to icd_list via add_icd.rhtml
  ######################################################################################################

  def add_icd
    begin
      if params[:visitid]
          @selected_diagnosis_codes = Patient.selected_diagnosis_codes(params[:visitid]).collect{|x|x.icd_code_id}
          @practice  = Practice.find(session[:practice_id])
          @patient = Visit.find(params[:visitid]).patient
          @visit = Visit.todays_visit(@patient.id)
      else
          @visit = Visit.todays_visit(params[:id])
          @patient = @visit.patient
          if !(@visit.nil?)
            @selected_diagnosis_codes = Patient.selected_diagnosis_codes(@visit.id).collect{|x|x.icd_code_id}
            @practice  = Practice.find(session[:practice_id])
          else
            flash[:error] = "No Visit recorded for today."
            logger.debug("No Visit recorded for today.")
            redirect_to :action=>'show',:id=>params[:id]
          end

      end
    rescue => e
      render :text=> " #{e.message}"
    end
  end


  ###################################################################################################
  #  action to display icd_list with check boxes for the user to select action to display icd_list
  ###################################################################################################

  def icd_list
    begin
      @practice_icd = Practice.find(session[:practice_id], :include => [:practice_icd_lists])
      new_practice_icd_ids = []
      for practice_icd_list in @practice_icd.practice_icd_lists
        temp = "check_"+ practice_icd_list.icd_code_id.to_s
        if !(params[temp].nil?)
          begin
           @visit_icd_info = VisitIcdInfo.create(:visit_id => params[:visitid],:practice_icd_list_id=>practice_icd_list.id)
          rescue
          end
          new_practice_icd_ids <<  practice_icd_list.id
        end
      end

      if new_practice_icd_ids != []
        VisitIcdInfo.delete_all(["visit_id = #{params[:visitid]} and practice_icd_list_id not in (?)", new_practice_icd_ids])
      end

    redirect_to :action=>'add_cpt',:visitid=>params[:visitid],:patientid=>params[:patientid],:cntrl_name=>params[:cntrl_name],:claim_id=>params[:claim_id]
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def add_cpt
    begin
      @patient = Visit.find(params[:visitid]).patient
      @practice  = Practice.find(session[:practice_id])
      @visit = Visit.todays_visit(@patient.id)
      # FIXME: Isnt the next line something like @visit._visit_cpt_list ?
      @selected_procedure_codes = Patient.selected_procedure_codes(params[:visitid]).collect{|x|x.cpt_code_id}
      #the above query to get the selected cpt codes and cpt codes for the visit
      @carriers = @practice.carriers.collect{|x|[x.id,x.name]}
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def cpt_list
    @practice  = Practice.find(session[:practice_id])
    @practice_cpt = @practice.cpt_codes
    new_practice_cpt_ids = []
    visit = Visit.find(params[:visitid])
    error_msg = []
    for practice_cpt in @practice_cpt
      temp = "check_"+ practice_cpt.id.to_s
      if !(params[temp].nil?)
        # calculating insurance portion and patient_portion
        # This routine internally creates the charge entries using a default
        # unit of 1 for each selected entry
        msg = Patient.charge_entry_charge_calculation(visit.patient_id,session[:practice_id],practice_cpt,visit)
        error_msg << msg
        new_practice_cpt_ids << practice_cpt.id
      end
    end

    if new_practice_cpt_ids != []
      ChargeEntry.delete_all(["visit_id = #{params[:visitid]} and cpt_charge_id not in (?)", new_practice_cpt_ids])
    end
    if error_msg.include?(false)
      flash[:notice]= '<font color=red>   FeeSchedule is not available for the Selected Codes. Please add the FeeSchedules.</font>'
      redirect_to :action=>'add_cpt',:visitid=>params[:visitid],:patientid=>params[:patientid],:cntrl_name=>params[:cntrl_name],:claim_id=>params[:claim_id]
    else
      redirect_to :action=>'map_icd_cpt', :visitid=>params[:visitid], :patientid=>params[:patientid], :cntrl_name=>params[:cntrl_name], :claim_id=>params[:claim_id]
    end
  end


 ########################################################################
  #  action to map icd and cpt codes with modifiers and number of units
  ########################################################################
  def map_icd_cpt
    @patient = Visit.find(params[:visitid]).patient
    @selected_procedure_codes = Patient.selected_procedure_codes(params[:visitid])
    charge_entry_ids = @selected_procedure_codes.collect{|s_p_c| s_p_c.charge_entry_id}
    @selected_charge_diagnosis = ChargeDiagnostic.find(:all, :conditions => ["charge_entry_id in (?)",charge_entry_ids ])
    @ccigrp_errors,@megrp_errors = NcciCcigrp.ncci_validations(@selected_procedure_codes.collect{|x|x.code})
    @claim = Claim.find_by_visit_id(params[:visitid])
    @visit = Visit.todays_visit(@patient.id)
    begin
      @selected_diagnosis_codes = Patient.selected_diagnosis_codes(params[:visitid])
      @modifiers = MopConstants::CPT_MODIFIERS
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  ################################################################################################
  #  action to map icd codes with check boxes and fileds to add modifiers and units for cpt_codes
  ################################################################################################
  def map_codes_list
    begin
        @selected_procedure_codes = Patient.selected_procedure_codes(params[:visitid])
        @charge_entries = ChargeEntry.find(:all,:conditions=>["visit_id=?",params[:visitid]],:include=>[:cpt_charge])
        sum_of_charge_entry = 0
        for charge_entry_info in @charge_entries
          ChargeDiagnostic.delete_all("charge_entry_id = #{charge_entry_info.id}")
          unit = "unit_" + charge_entry_info.id.to_s
          params[unit] = 1 if params[unit].empty?
          charge = params[unit].to_f * (charge_entry_info.charge/charge_entry_info.num_units)

          # updating the charge entries with multiplying units with patient portion and insurance portion
          charge_entry_info.update_attributes(:num_units=> params[unit],
                                              :charge => charge)
          # calculating sum of charge_entry
          sum_of_charge_entry += charge
          visit_id = "visit_" + charge_entry_info.id.to_s
          visit_charge_ids = params[visit_id].split(',')

          count = 1
          for visit_id in visit_charge_ids
            temp = "check_"+ charge_entry_info.id.to_s + "_" + visit_id.to_s
            if !(params[temp].nil?)
              ChargeDiagnostic.create(:charge_entry_id => charge_entry_info.id,:visit_icd_info_id => visit_id,:position=>count)
            end
            count = count +1
          end

        end  # END for charge_entry_info in @charge_entries

        # visit insurance and patient portion calculation
        Patient.visit_ins_pat_calculation(sum_of_charge_entry,params[:visitid],params[:patientid])
        claim = Claim.find_by_visit_id(params[:visitid])
        if claim
          update_claim_dates(claim.id)
        end
       if params[:cntrl_name] == "claims"
        redirect_to :controller=>'claims',:action=>'edit_claim_pdf',:visitid=>params[:visitid],:claim_id=>params[:claim_id],:error_flag=>params[:error_flag]
       elsif params[:cntrl_name] == "claim_error"
        redirect_to :controller=>'claims',:action=>'claim_error',:visitid=>params[:visitid],:claim_id=>params[:claim_id],:error_flag=>params[:error_flag]
       else
          redirect_to :controller=>"patients",:action=>"show",:id=>params[:patientid]
       end
     rescue => e

     render :text=> " #{e.message}"
    end
  end

  #adding the modifiers for each procedure code
  def update_modifiers
    begin
    for modifier in params[:modifier]
      # gsub function used replace the "," and space values in charge_modifiers using ascii key
      modifier = modifier.gsub('%2520',' ')
      modifier = modifier.gsub('%252C',', ')
      ChargeModifier.create(:charge_entry_id=>params[:charge_entry_id],:modifier=>modifier)
    end
    @charge_entry = ChargeEntry.find(params[:charge_entry_id])
    @id = "selected_modifier_" + params[:charge_entry_id]
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  ##########################################
  # method to delete the selected modifiers
  ##########################################
  def delete_selected_modifiers
    begin
      @charge_entry_modifier = ChargeModifier.find(params[:id])
      @charge_entry = ChargeEntry.find(@charge_entry_modifier.charge_entry_id)
      @charge_entry_modifier.destroy
      @id = "selected_modifier_" + @charge_entry_modifier.charge_entry_id.to_s
    rescue => e
      render :text=> " #{e.message}"
    end
  end

  def edit_charge_entry
    charge_entry = ChargeEntry.find(params[:edit_charge_entry])
    charge_entry.update_attributes(:facility_type_code=>params[:charge_entry][:facility_type_code],
                                   :end_date => Patient.date_split(params[:charge_entry][:end_date]),
                                   :certification_revision_date => Patient.date_split(params[:charge_entry][:certification_revision_date]),
                                   :begin_therapy_date => Patient.date_split(params[:charge_entry][:begin_therapy_date]),
                                   :last_certification_date => Patient.date_split(params[:charge_entry][:last_certification_date]),
                                   :test_date => Patient.date_split(params[:charge_entry][:test_date]),
                                   :arterial_blood_gas_test_date => Patient.date_split(params[:charge_entry][:arterial_blood_gas_test_date]),
                                   :shipped_date => Patient.date_split(params[:charge_entry][:shipped_date]),
                                   :onset_of_similar_illness_date => Patient.date_split(params[:charge_entry][:onset_of_similar_illness_date]),
                                   :last_xray_date => Patient.date_split(params[:charge_entry][:last_xray_date]),
                                   :acute_manifestation_date => Patient.date_split(params[:charge_entry][:acute_manifestation_date]),
                                   :initial_treatment_date => Patient.date_split(params[:charge_entry][:initial_treatment_date]),
                                   :onset_of_current_symptom_date => Patient.date_split(params[:charge_entry][:onset_of_current_symptom_date])
                                   )
    render :text=> '<font color=green>Service Dates Updated for the Selected CPT CODE.</font>'
  end

  def show_service_dates
    @charge_entry = ChargeEntry.find(params[:id])
    render :partial=>'edit_service_dates'
  end

  # adding cpt codes through patients - EMR
  def add_cptcode_charge
    @practice  = Practice.find(session[:practice_id], :include => [:cpt_codes])
    @selected_procedure_codes = Patient.selected_procedure_codes(params[:visitid]).collect{|x|x.cpt_code_id}
    @carriers = @practice.carriers.collect{|x|[x.id,x.name]}
    @cpt_code = CptCode.find_by_code(params[:cpt_code_id])
    if @cpt_code
      if !@practice.cpt_codes.collect{|x|x.code}.include?(@cpt_code.code)

      if !params[:standard_charge].empty?
      CptCharge.create(:practice_id=>session[:practice_id],
                      :cpt_code_id=>@cpt_code.id,
                      :charge=>params[:standard_charge],
                      :fee_schedule_id=>FeeSchedule.find_by_practice_id_and_charge_type(session[:practice_id],'Standard').id
                      )
            @flag = true
       else
          @flag = false
       end
       for carrier in @carriers
        temp = "carrier_"+carrier[0].to_s
        fee_schedule = FeeSchedule.find_by_practice_id_and_carrier_id(session[:practice_id],carrier[0])
        fee_schedule = FeeSchedule.create(:charge_type=>'Allowed',
                                          :carrier_id=>carrier[0],
                                          :practice_id=>session[:practice_id],
                                          :start_date => Time.now.at_beginning_of_year.strftime("%Y-%m-%d"),
                                          :end_date => Time.now.at_beginning_of_year.strftime("%Y") + "-12-31") if !fee_schedule
        CptCharge.create(:practice_id=>session[:practice_id],
                        :cpt_code_id=>@cpt_code.id,
                        :charge=>params[temp],
                        :fee_schedule_id=>fee_schedule.id
                        ) if !params[temp].empty?
       end
      end
    end
    @practice.reload
  end

  def add_icdcode
    @selected_diagnosis_codes = Patient.selected_diagnosis_codes(params[:visitid]).collect{|x|x.icd_code_id}
    @practice  = Practice.find(session[:practice_id], :include => [:icd_codes])
    @flag = []
    for i in 1..3
      temp = "icd_code_" + i.to_s
      if !params[temp].empty?
        icd_code = IcdCode.find_by_code(params[temp])
        if icd_code
          if !@practice.icd_codes.collect{|x|x.code}.include?(icd_code.code)
            PracticeIcdList.create(:practice_id=>session[:practice_id],:icd_code_id=>icd_code.id)
            @flag << '<font color=green>ICD code ' + i.to_s + ' added successfully.</font><br/>'
          else
            @flag << '<font color=red>The given ICD code ' + i.to_s + ' already exists.</font><br/>'
          end
        else
          @flag << '<font color=red>Wrong ICD code ' + i.to_s + '.</font><br/>'
        end
      end
      icd_code = nil
    end
    @practice.reload
  end

  def checkout_auto_fill
   if params[:patient_id]
    @patient = Patient.find(params[:patient_id])
    patients = Patient.find_all_by_responsible_party_id(@patient.responsible_party_id,:select=>'id')
    @visits = Visit.find(:all,:conditions=>["practice_id =? and patient_id in(?) and patient_due > 0",session[:practice_id],patients])
   else
    patient = Patient.find_all_by_responsible_party_id(params[:rp_id],:select=>'id')
    @visits = Visit.find(:all,:conditions=>["practice_id =? and patient_due > 0 and patient_id in (?)",session[:practice_id],patient])
   end
   @fill_amount = []
   unattributed_amount = params[:amount]
   for visit in @visits
     @fill_amount,unattributed_amount = Payment.fill_amount_calculation(1,visit.patient_due,unattributed_amount,@fill_amount)
   end
    render :partial=>'patients/checkout_visit_details'
  end
  ##################### PRIVATE METHODS ##########################
  private

  def set_visit_id
    begin
      @visit = (params[:id]) ? Visit.todays_visit(params[:id]) : Visit.new
    rescue => e
      render :text=> " #{e.message}"
    end
  end

end