#
# Copyright (c) 2014-2015 Chef Software Inc. 
# License :: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Author: Mark Anderson <mark@chef.io>
#

require 'pp'
require_relative 'config'
require_relative 'authz_objects'

module ChefFixie
  module AuthzMapper

    #
    # It would be really awesome if this was integrated with the
    # AuthzObjectMixin so that when it was mixed in, we automatically
    # added code to the reverse mapping
    #
    #
    # Much of this might be better folded up into a sql stored procedure
    #
   
    def self.included(base)
      base.extend(ClassMethods)
    end

    def authz_to_name(authz_id)
      objects = by_authz_id(authz_id).all(1)
      scope = :unknown
      name = :unknown
      if objects.count == 1
        object = objects.first
        name = object.name
        scope = 
          if object.respond_to?(:org_id) 
              ChefFixie::Sql::Orgs.org_guid_to_name(object.org_id)
          else
            :global
          end
        [scope, name]
      else
        :unknown
      end
    end

    class ReverseMapper
      attr_reader :names,:by_type, :instance
                     
      def initialize
        # name of object map
        @names ||= {}
        @by_type ||= {:actor=>{}, :container=>{}, :group=>{}, :object=>{}}
        # maps class to a pre-created instance for efficiency
        @instance ||= {}
      end

      def class_cache(klass)
        instance[klass] ||= klass.new
      end

      def register(klass, name, type)
        names[name] = klass
        by_type[type][name] = klass
      end
      
      def dump
        pp names
      end

      def authz_to_name(authz_id, ctype=nil)
        types = if ctype.nil?
                  AuthzUtils::Types
                else
                  [ctype]
                end
        types.each do |type|
          by_type[type].each_pair do |name, klass|
            result = class_cache(klass).authz_to_name(authz_id)
            return result if result != :unknown
          end
        end
        return :unknown
      end
    end

    def self.mapper
      @mapper ||= ReverseMapper.new
    end
    
    def self.register(klass, name, type)
      self.mapper.register(klass,name,type)
    end

    # Translates the json from authz for group membership and acls into a human readable form
    # This makes some assumptions about the shape of the data structure, but works well enough to
    # be quite useful
    def self.struct_to_name(s)
      mapper = AuthzMapper::mapper      
      if s.kind_of?(Hash)
        s.keys.inject({}) do |h, k|
          v = s[k]
          if v.kind_of?(Array)
            case k
            when 'actors'
              h[k] = v.map {|a| mapper.authz_to_name(a,:actor) } #.sort We should sort these, but the way we're returning unknown causes sort 
            when 'groups'
              h[k] = v.map {|a| mapper.authz_to_name(a,:group) } #.sort to fail
            else
              h[k] = v
            end
          else
            h[k] = self.struct_to_name(v)
          end
          h
        end
      end
    end
    
    module ClassMethods
      # TODO: We should be able to automatically figure out the type somehow.
      # At minimum should figure out a self check
      def register_authz(name, type)
        AuthzMapper::register(self,name,type)
      end
    end
    
  end
end