# encoding: utf-8
class ArchiveFile
  include Mongoid::Document
  include Mongoid::Timestamps

  include OrbitCategory::Categorizable
  include OrbitModel::Status
  include OrbitTag::Taggable
  include Slug
  require 'archive_model/cache'
  unless defined?(ArchiveModel)
    Object.send(:remove_const, 'ArchiveModel') rescue nil
    $LOADED_FEATURES.select!{|p| !p.include? 'archive_model'}
    require 'archive_model/cache'
  end
  include ::ArchiveModel::Cache
  SubPart.class_eval { include ::ArchiveModel::Cache }
  Page.class_eval { include ::ArchiveModel::Cache }
  index({tmp_sort_number: 1})
  scope :sorted, ->{order(tmp_sort_number: :asc)}
  attr_accessor :org_tag_ids,:org_category_id
  def tags=(ids)
    self.org_tag_ids = self.tag_ids
    super(ids)
  end
  def category=(cat)
    self.org_category_id = self.category_id
    super(cat)
  end
  def tag_ids=(ids)
    self.org_tag_ids = self.tag_ids
    super(ids)
  end
  def category_id=(cat_id)
    self.org_category_id = self.category_id
    super(cat_id)
  end
  def []=(index,value)
    if index.to_s=='tags' || index.to_s=='tag_ids'
      self.org_tag_ids = self.tag_ids
    elsif index.to_s=='category' || index.to_s=='category_id'
      self.org_category_id = self.category_id
    end
    super(index,value)
  end
  # include Tire::Model::Search
  # include Tire::Model::Callbacks

  # BelongsToCategory =  :archive_file_category

  # PAYMENT_TYPES = @site_valid_locales
  before_save do
    unless @skip_callback
      cat = self.category rescue nil
      if cat && ArchiveCategory.where(:category_id => cat.id).count==0
        ArchiveCategory.create(category_id: cat.id.to_s,sort_number: cat.sort_number)
      end
    end
  end
  after_save do
    unless @skip_callback
      if self.sort_number_changed?
        self.class.recalc_sort_number
      elsif self.tmp_sort_number.nil?
        if self.is_top
          self.tmp_sort_number = (ArchiveSortOrder.first.max_sort_number.to_i + 1 rescue 1)
          @skip_callback = true
          self.save
          @skip_callback = false
        else
          self.class.recalc_sort_number
        end
      end
    end
  end
  field :title, as: :slug_title, localize: true
  field :description, localize: true
  field :urls, localize: true, type: Array
  field :url, localize: true #Old field
  field :url_texts, localize: true, type: Array, default: []
  field :create_user_id
  field :update_user_id
  field :postdate , :type => DateTime, :default => Time.now
  field :deadline , :type => DateTime
  field :uid, type: String
  field :sort_number, type: Integer
  field :tmp_sort_number, type: Integer
  field :rss2_sn
  field :feed_uid
  field :site_feed_id
  field :feed_data, :type => Hash, :default => {}
  # scope :can_display,where(is_hidden: false)
  scope :local_data, ->{where(:site_feed_id=>nil)}
  scope :can_display, ->{where(is_hidden: false,:title.nin=>["",nil])}
  scope :can_display_and_sorted, ->{can_display.sorted}
  # belongs_to :archive_file_category

  has_many :archive_file_multiples, :autosave => true, :dependent => :destroy

  accepts_nested_attributes_for :archive_file_multiples, :allow_destroy => true

  # validates :title, :at_least_one => true

  after_save :save_archive_file_multiples, :update_tmp_sort_number

  before_save :add_http

  after_initialize do
    unless self.new_record?
      if self.urls.nil? && self.url.present?
        self.urls_translations = self.url_translations.map{|k,v| [k,[v]]}.to_h
        self.save
      end
    end
  end
  def self.check_sort_number
    archive_sort_order = ArchiveSortOrder.first
    if archive_sort_order && archive_sort_order.need_update_sort
      self.recalc_sort_number(archive_sort_order.sort_order)
    end
  end
  def self.recalc_sort_number(sort_order=nil)
    if sort_order.nil?
      sort_order = (ArchiveSortOrder.first['sort_order'] rescue false) ? 1 : -1
    end
    sorted_archives = self.all.to_a.sort_by{|k| [(k["is_top"] ? 0 : 1) ,(k["sort_number"].nil? ? Float::INFINITY : sort_order * k["sort_number"].to_i),-k["created_at"].to_i]}
    sorted_archives.each_with_index do |a, i|
      a.instance_variable_set(:@skip_callback, true)
      self.where(:id=>a.id).update_all(:tmp_sort_number => i)
    end
    min_sort_number, max_sort_number = (sorted_archives.count != 0) ? (sorted_archives.map{|a| a.sort_number.to_i}.minmax) : [0, 0]
    ArchiveSortOrder.update_all(:min_sort_number=>min_sort_number,:max_sort_number=>max_sort_number,:need_update_sort=>false)
    self.create_indexes
    return max_sort_number
  end
  def update_tmp_sort_number
    return if @skip_callback
    if self.new_record? || self.sort_number_changed?
      self.class.recalc_sort_number
    end
  end
  def get_url_text(idx=0,org=false)
    url_text = self.url_texts[idx] rescue nil
    if org
      url_text
    else
      url_text.present? ? url_text : "link"
    end
  end
  def get_data(more_url=nil, base_url=nil, cat_ids=nil, tag_ids=nil, locales=nil)
    if locales.nil?
      locales = Site.first.in_use_locales rescue I18n.available_locales
    end
    locale = I18n.locale if locale.nil?
    base_url = Site.first.root_url if base_url.nil?
    user = User.find(self.create_user_id) rescue nil
    a = {}
    if !user.nil?
      author_translations = user.member_name_translations
      locales.each do |locale|
        if author_translations[locale].blank?
          author_translations[locale] = user.user_name
        end
      end
    else
      author_translations = {}
    end
    a["author_translations"] = author_translations
    if more_url.nil?
      if cat_ids.nil?
        cat_ids = [self.category_id]
      end
      if tag_ids.nil?
        tag_ids = self.tag_ids
      end
      basic_query = {:module => 'archive',:enabled_for=>locale}
      if !cat_ids.blank?
        query = basic_query.merge({:categories.all => cat_ids})
      else
        query = basic_query.clone
      end
      if !tag_ids.blank?
        query = query.merge({:tags.all => tag_ids})
      end
      page = Page.where(query).first || Page.where(basic_query).first
      more_url = page ? page.get_url : nil
    end
    if more_url
      a['show_url'] = "#{more_url}/#{self.to_param}"
    end
    a["id"] = self.uid
    a["title_translations"] = self.title_translations
    a["description_translations"] = {}
    description_translations = self.description_translations
    locales.each do |locale|
      locale = locale.to_s
      a["description_translations"][locale] = self.class.smart_convertor(description_translations[locale],base_url) if !description_translations[locale].blank?
    end
    a["created_at"] = self.created_at
    a["url_translations"] = self.url_translations
    a["tags"] = []
    a["category"] = {}
    a["files"] = []
    a["params"] = self.to_param
    self.tags.each do |tag|
      if !tag_ids.include?(tag.id.to_s)
        tag_ids << tag.id.to_s
      end
      a["tags"] << {"name_translations" => tag.name_translations}
    end
    cat = self.category
    a["sort_number"] = nil
    a["category"] = {"title_translations" => (cat.title_translations rescue {})}
    self.archive_file_multiples.order_by(:sort_number=>'desc').each do |file|
      if file.choose_lang.include?(I18n.locale.to_s)
        title_translations = {}
        locales.each do |locale|
          title_translations[locale] = (file.file_title_translations[locale].blank? ?  File.basename(file.file.path) : file.file_title_translations[locale]) rescue ""
        end
        extension = file.file.file.extension.downcase rescue ""
        a["files"] <<  {
          "file-name_translations" => title_translations,
          "file-type" =>  extension,
          "file-url" => "#{base_url}/xhr/archive/download?file=#{file.id}"
        }
      end
    end
    return a
  end
  def get_related_feeds
    related_feeds = ArchiveFileFeed.where({:category_ids=>self.category_id.to_s, :tag_ids.in=>self.tag_ids.map(&:to_s)}).to_a
  end
  def update_feed_statuses(statuses) #ex: statuses = {:is_top=>1}
    self.update(statuses)
  end
  def update_feed_data(data)
    data = data.clone
    feed_data_keys = ["author_translations", "tags", "category", "files", "params", "show_url"]
    data["feed_data"] = {}
    data["feed_uid"] = data["id"]
    data.delete("id")
    feed_data_keys.each do |k|
      data["feed_data"][k] = data[k]
      data.delete(k)
    end
    @skip_callback = true
    # ArchiveSortOrder.update_all(:need_update_sort=>true)
    self.update(data)
    @skip_callback = nil
  end
  def self.feeds_finish_callback(action="update", args={})
    if action != "destroy"
      if action == "update_all"
        data = args["data"]
        if data
          site_feed_id = args["feed_id"]
          category_id = args["category_id"]
          data.each do |a|
            a["category_id"] = category_id if category_id
            archive_file = self.where(:feed_uid=> a["id"], :site_feed_id=>site_feed_id).first
            if archive_file.nil?
              archive_file = self.new(:feed_uid=> a["id"], :site_feed_id=>site_feed_id)
              archive_file.instance_variable_set(:@skip_callback, true)
              archive_file.save
            end
            archive_file.update_feed_data(a)
          end
          self.where(:feed_uid.nin=>data.map{|a| a["id"]}, :site_feed_id=>site_feed_id).destroy
        end
      end
      self.recalc_sort_number
    end
    ArchiveCache.destroy_all
  end
  def get_files(locale=nil, serial_number=0)
    if locale.nil?
      locale = I18n.locale.to_s
    end
    files = []
    if self.feed_uid
      files = self.feed_data["files"].map do |h|
        serial_number += 1
        h = h.clone
        h["file-name"] = h["file-name_translations"][locale]
        h.delete("file-name_translations")
        h["serial_number"] = serial_number
        h
      end
    else
      self.archive_file_multiples.order_by(:sort_number=>'desc').each do |file|
        if file.choose_lang.include?(locale)
          title = (file.file_title.blank? ?  File.basename(file.file.path) : file.file_title) rescue ""
          extension = file.file.file.extension.downcase rescue ""
          serial_number += 1
          files <<  {
            "file-name" => title,
            "file-type" =>  extension,
            "file-url" => "/xhr/archive/download?file=#{file.id}",
            "serial_number" => serial_number
          }
        end
      end
      if self.urls.present?
        self.urls.each_with_index do |url,i|
          serial_number += 1
          files <<  {
            "file-name" => self.title,
            "file-type" => self.get_url_text(i),
            "file-url" => url,
            "serial_number" => serial_number
          }
        end
      end
    end
    [files, serial_number]
  end
  def get_frontend_data(locale=nil, serial_number=0, idx=0, show_tags=false, more_url=nil)
    created_at_int = self.created_at.strftime('%Y%m%d').to_i
    statuses = self.statuses_with_classname.collect do |status|
      {
        "status" => status["name"] || "",
        "status-class" => "status-#{status['classname']}"
      }
    end
    files, serial_number = self.get_files(locale, serial_number)
    data = {
      "archive-file-url" => (files.count != 0 ? files[0]["file-url"] : "javascript:void"),
      "archive-title" => self.title,
      "description" => self.description,
      "created_at" => created_at_int,
      "archive-url" => self.url,
      "url" => self.url,
      "statuses" => statuses,
      "sort_number" => self.sort_number,
      "is_top" => (self.is_top ? 1 : 0),
      "files" => files,
      "idx" => (idx + 1)
    }
    if show_tags
      data["tags"] = self.tags.map do |tag|
        {"name"=>tag.name, "url"=>more_url.to_s + "?tags[]=#{tag.id}"}
      end
    end
    if more_url
      data["index_url"] = more_url
    end
    return [data, serial_number, idx]
  end
  def get_archive_url(locale, more_url)
    archive_url = ""
    if self.feed_uid
      files = self.feed_data["files"]
      if files.count == 0
        tmp_urls = self.urls
        archive_url = ((tmp_urls.nil? || tmp_urls.count == 0) ? 'javascript:void' : (tmp_urls.count > 1 ? (more_url + '?title=' + self.title.to_s) : tmp_urls[0]))
      else
        archive_url = files.count > 1 ? (more_url + '?title=' + self.title.to_s) : files[0]["file-url"]
      end
    else
      if self.archive_file_multiples.count==0
        tmp_urls = self.urls
        archive_url = ((tmp_urls.nil? || tmp_urls.count == 0) ? 'javascript:void' : (tmp_urls.count > 1 ? (more_url + '?title=' + self.title.to_s) : tmp_urls[0]))
      else
        archive_url = self.archive_file_multiples.count > 1 ? (more_url + '?title=' + self.title.to_s) : "/xhr/archive/download?file=#{self.archive_file_multiples.first.id}"
      end
    end
    archive_url
  end
  def notify_feed(type="create")
    related_feeds = self.get_related_feeds.select{|feed| feed.remote_urls.count != 0}
    if related_feeds.count != 0
      archive_data = self.get_data
      if type == "destroy"
        tmp_data = {'type'=>'destroy', 'data'=>[self.uid]}
      else
        tmp_data = {'type'=>type, 'data'=>[archive_data.to_json]}
      end
      request = Net::HTTP::Post.new('/xhr/feeds/notify_change', 'Content-Type' => 'application/json')
      related_feeds.each do |feed|
        tmp_data['uid'] = feed.uid
        request.body = tmp_data.to_json
        feed.remote_urls.each do |remote_url|
          uri = URI(remote_url)
          http_req = Net::HTTP.new(uri.host, uri.port)
          if remote_url.include?('https')
            http_req.use_ssl = true
          end
          response = self.class.http_request( http_req , request )
        end
      end
    end
  end
  def self.notify_feed_delete(ids)
    all_feeds = ArchiveFileFeed.all.select{|feed| feed.remote_urls.count != 0}
    if all_feeds.count != 0
      tmp_data = {'type'=>'destroy'}
      request = Net::HTTP::Post.new('/xhr/feeds/notify_change', 'Content-Type' => 'application/json')
      all_feeds.each do |feed|
        feed_uid = feed.uid
        feed_cache = ArchiveFileFeedCache.where(:uid=>feed_uid).first
        if feed_cache
          tmp_data['uid'] = feed_uid
          tmp_data['data'] = ids & JSON.parse(feed_cache.content)["archives"].map{|a| a["id"]}
          request.body = tmp_data.to_json
          if tmp_data['data'].count != 0
            feed.remote_urls.each do |remote_url|
              uri = URI(remote_url)
              http_req = Net::HTTP.new(uri.host, uri.port)
              if remote_url.include?('https')
                http_req.use_ssl = true
              end
              response = self.http_request( http_req , request )
            end
          end
        end
      end
    end
  end
  def self.http_request(http, request)
    response = http.request(request)
    if response.code.to_i == 301 || response.code.to_i == 302
      location = response["location"]
      new_uri = URI(location)
      http = Net::HTTP.new(new_uri.host, new_uri.port)
      if location.include?('https')
        http.use_ssl = true
        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
      end
      request.instance_variable_set(:@path, new_uri.path)
      response = self.http_request(http, request)
    end
    response
  end
  protected
  def add_http
    return if @skip_callback
    in_use_locales = Site.first.in_use_locales
    temp_urls = {}
    in_use_locales.each do |locale|
      locale = locale.to_s
      temp_urls[locale] = []
      self.urls_translations[locale].each do |tmp_url|
        tmp = tmp_url
        if tmp.present?
          unless /^(http|https|ftp):\/\/[\S]+/.match(tmp_url) || url.include?("mailto:")
            tmp = 'http://' + tmp_url
          end
          temp_urls[locale] << tmp
        end
      end rescue nil
    end
    self.urls_translations = temp_urls
  end

  # def to_indexed_json
  #   self.to_json
  # end
  
  # search_in :title

  # searchable do
  #   text :titles do
  #     title_translations.to_a.collect{|t| t[1]}
#   end
  #   boolean :frontend_search do
  #     !is_hidden
  #   end

  # end
  

 #  def self.search( category_id = nil )

	# if category_id.to_s.size > 0

	#   find(:all, :conditions => {archive_file_category_id: category_id}).desc( :is_top, :title )

	# else

	#   find(:all).desc( :is_top, :title)

	# end

 #  end

  def self.find_by_param(input)
    self.find_by(uid: input)
  end

  def self.widget_datas

	  where( :is_hidden => false ).desc(:is_top, :title)

  end


  def get_file_icon( file_data )
    file_icon = "<span class=\"o-archives-file-type\">#{file_data.split('.')[-1]}</span>".html_safe
  end

  def save_archive_file_multiples
    return if @skip_callback
  	self.archive_file_multiples.each do |t|
  	  if t.should_destroy
  		  t.destroy
  	  end
    end
  end
  def self.smart_convertor(text,url)
    doc = Nokogiri.HTML(text)
    doc.search('a[href]').each do |link|
      if link['href'].nil?
        link.delete 'href'
      elsif link['href'].start_with?('/')
        link['href'] = url + link['href']
      elsif link['href'].start_with?('../')
        link['href'] = url + link['href'][3..-1]
      end
    end
    doc.search('img[src]').each do |link|
      if link['src'].nil?
        link.delete 'src'
      elsif link['src'].start_with?('/')
        link['src'] = url + link['src']
      elsif link['src'].start_with?('../')
        link['src'] = url + link['src'][3..-1]
      end
    end

    return doc.css('body').inner_html
  end
end