class Admin::PurchasesController < ApplicationController
  require "net/http"
  require "uri"
  require 'zip/zip'
  
  layout "new_admin"
  
  def index
    @purchases = Purchase.all.entries
  end

  def buy_template
    original_file, zip_name = download_template(params[:id])
    temp_file = Tempfile.new("temp_file_zip")
    temp_file.binmode
    temp_file.write original_file
    temp_file.rewind
    unzip_design(temp_file, zip_name)
    temp_file.close
    temp_file.unlink
  end

  def download
    @purchase = Purchase.first(:conditions => {:id => params[:id]})
    download_purchase(@purchase, request.env['REQUEST_URI'].split('admin')[0].chop)
    @purchase.downloaded = true
    @purchase.save
    redirect_to admin_purchases_url
  end

  def install_app
    unzip_app
    redirect_to admin_purchases_url

  end

  protected
  
  def download_purchase(purchase, url)
    uri = URI.parse("http://#{APP_CONFIG['store_ip']}/download/purchase")
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Post.new(uri.request_uri)
    
    public_key = OpenSSL::PKey::RSA.new(File.read(APP_CONFIG['main_public_key']))
    encrypted_data = public_key.public_encrypt({:purchase_id => purchase.purchase_id,
                                                :purchase_type => purchase.class.to_s,
                                                :roaming_id => Site.find(session[:site]).roaming_id,
                                                :url => url}.to_json)
    
    request.set_form_data({ :purchase => encrypted_data})
    response = http.request(request)
    temp_file = Tempfile.new("temp_file")
    temp_file.binmode
    temp_file.write response.body
    temp_file.rewind
    zip_name = response['content-disposition'].split('filename=')[1].gsub(/[\\\"]|.zip/, '') rescue ''
    case purchase.class.to_s
      when 'Pdesign'
        unzip_design(temp_file, zip_name)
      when 'PModuleApp'
        unzip_module_app(temp_file, zip_name)
    end
    temp_file.close
    temp_file.unlink
  end
  
  def unzip_design(file, zip_name)
    Zip::ZipFile.open(file) do |zip_file|
      encrypted = {}
      ['encrypted_data', 'encrypted_key', 'encrypted_iv'].each do |e|
        encrypted.merge!(e => zip_file.read(e))
      end
      orig_file = decrypt_data(encrypted['encrypted_data'], encrypted['encrypted_key'], encrypted['encrypted_iv'])
      
      temp_file = Tempfile.new("temp_file_zip")
      temp_file.binmode
      temp_file.write orig_file
      temp_file.rewind
      
      Zip::ZipFile.open(temp_file) { |orig_zip|
        design = Design.new.from_json(orig_zip.read("#{zip_name}/#{zip_name}.json"))
        Dir.mktmpdir('f_path') { |dir|
          
          build_file(orig_zip, zip_name, dir, design.layout) if design.layout
          build_file(orig_zip, zip_name, dir, design.css_default) if design.css_default
          build_file(orig_zip, zip_name, dir, design.css_reset) if design.css_reset
          
          ['themes', 'javascripts', 'images'].each do |type|
            design.send(type).each do |object|
              build_file(orig_zip, zip_name, dir, object, type)
            end
          end
        }
        temp_file.close
        temp_file.unlink
        design.save
      }
      
    end
  end
  
  def unzip_app
    zip_name = "NewBlog"
    file = "#{Rails.root}/lib/NewBlog.zip"
    destination = "#{Rails.root}/vendor/plugins"
    
    Zip::ZipFile.open(file) do |zip_file|
      orig_file = file
      
      temp_file = Tempfile.new("temp_file_zip")
      temp_file.binmode
      temp_file.write orig_file
      temp_file.rewind

      app = AppModule.new.from_json(zip_file.read("#{zip_name}/#{zip_name}/#{zip_name}.json"))
      zip_file.each do  |f|
         if (f.to_s=~/^#{zip_name}\/#{zip_name}\/*/)
            f_path=File.join(destination, f.name.gsub(/^#{zip_name}\//, ''))
            FileUtils.mkdir_p(File.dirname(f_path))
            zip_file.extract(f, f_path) unless File.exist?(f_path)
          end
      end
      
      log = Logger.new(STDOUT)
      log.level = Logger::WARN
      log.warn(t(:unzip_app))
      
      #TODO Perform touch tmp/restart to restart in production env
    end
  end
  
  def unzip_module_app(file, zip_name)
    destination = "#{Rails.root}/vendor/plugins"
    Zip::ZipFile.open(file) do |zip_file|
      encrypted = {}
      ['encrypted_data', 'encrypted_key', 'encrypted_iv'].each do |e|
        encrypted.merge!(e => zip_file.read(e))
      end
      orig_file = decrypt_data(encrypted['encrypted_data'], encrypted['encrypted_key'], encrypted['encrypted_iv'])
      
      temp_file = Tempfile.new("temp_file_zip")
      temp_file.binmode
      temp_file.write orig_file
      temp_file.rewind

      Zip::ZipFile.open(temp_file) { |orig_zip|
        module_app = ModuleApp.new.from_json(orig_zip.read("#{zip_name}/#{zip_name}.json"))
        orig_zip.remove("#{zip_name}/#{zip_name}.json")

        orig_zip.each do |orig|
          inner_temp_file = Tempfile.new("inner_temp_file_zip")
          inner_temp_file.binmode
          inner_temp_file.write orig_zip.read(orig)
          inner_temp_file.rewind
          
          Zip::ZipFile.open(inner_temp_file) {|inner_zip|
            inner_zip.each do |f|
              if (f.to_s=~/^#{zip_name}\/*/)
                f_path = File.join(destination, f.name)
                FileUtils.mkdir_p(File.dirname(f_path))
                inner_zip.extract(f, f_path) unless File.exist?(f_path)
              end
            end
          }
          inner_temp_file.close
          inner_temp_file.unlink
        end

        module_app.save

        log = Logger.new(STDOUT)
        log.level = Logger::WARN
        log.warn(t(:unzip_app))
      }
      
      temp_file.close
      temp_file.unlink
      
    end
  end
  
  
  
  
  def build_file(orig_zip, zip_name, dir, object, type = nil)
    title = object.file_identifier
    temp = File.new(dir + '/' + title, 'w+')
    temp.write orig_zip.read(zip_name + '/' + (type ? (type + '/') : '') + title)
    object.file = temp
    object.to_save = true
  end

  def unzip_file (file, destination)
  
  end


  def download_template(id)
    uri = URI.parse("http://#{APP_CONFIG['store_ip']}/download/design/#{id}")
    http = Net::HTTP.new(uri.host, uri.port)
    request = Net::HTTP::Get.new(uri.request_uri)
    response = http.request(request)
    [response.body, (response['content-disposition'].split('filename=')[1].gsub(/[\\\"]|.zip/, '') rescue '')]
  end

  def unzip_design(input_file, zip_name)
    temp_file = Tempfile.new("temp_file")
    temp_file.write(input_file.read.force_encoding('UTF-8'))
    temp_file.rewind
    Zip::ZipFile.open(temp_file) { |zip_file|
      design = Design.new.from_json(zip_file.read("#{zip_name}/info.json"))
      Dir.mktmpdir('f_path') { |dir|
        themes_entries = []
        javascripts_entries = []
        images_entries = []
        screenshots_entries = []

        zip_file.entries.each do |entry|
          case (path = entry.to_s)
            when /\A(#{zip_name})\/(default\.css)\z/    #for default css
              design.build_css_default(:file => get_temp_file(zip_file, dir, entry))
            when /\A(#{zip_name})\/(reset\.css)\z/    #for reset css
              design.build_css_reset(:file => get_temp_file(zip_file, dir, entry))
            when /\A(#{zip_name})\/(layout\.html)\z/    #for layout html
              design.build_layout(:file => get_temp_file(zip_file, dir, entry))
            when /\A(#{zip_name})\/(thumb((\.jpg)|(\.png)|(\.gif)))\z/    #for thumb
              design.build_thumb(:file => get_temp_file(zip_file, dir, entry))
            when /\A(#{zip_name})\/(themes)\/.*(\.css)\z/   #for themes css
              themes_entries << entry
            when /\A(#{zip_name})\/(javascripts)\/.*(\.js)\z/   #for js
              javascripts_entries << entry
            when /\A(#{zip_name})\/(images)\/.*((\.jpg)|(\.png)|(\.gif))\z/   #for img
              images_entries << entry
            when /\A(#{zip_name})\/(screenshots)\/.*((\.jpg)|(\.png)|(\.gif))\z/   #for img
              screenshots_entries << entry
          end
        end

        ['themes', 'javascripts', 'images', 'screenshots'].each do |type|
          eval("#{type}_entries").each do |entry|
            eval("design.#{type}").build(:file => get_temp_file(zip_file, dir, entry))
          end
        end
      }
      design.zip_file = input_file
      design.save
    }
    temp_file.close
    temp_file.unlink
  end

  def get_temp_file(zip_file, dir, entry)
    filename = File.basename(entry.to_s)
    temp_file = File.new(dir + '/' + filename, 'w+') 
    temp_file.write (zip_file.read entry ).force_encoding('UTF-8')
    temp_file
  end

end