#
#       ActiveFacts Generators.
#       Generate json output from a vocabulary, for loading into APRIMO
#
# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
#
require 'json'
require 'digest/sha1'

module ActiveFacts
  module Generate
    # Generate json output from a vocabulary, for loading into APRIMO.
    # Invoke as
    #   afgen --json <file>.cql=diagrams
    class JSON
    private
      def initialize(vocabulary)
        @vocabulary = vocabulary
        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
      end

      def puts(*a)
        @out.puts *a
      end

    public
      def generate(out = $>)
        @out = out
        uuids = {}

        puts "{ model: '#{@vocabulary.name}',\n" +
        "diagrams: [\n#{
          @vocabulary.all_diagram.sort_by{|o| o.name.gsub(/ /,'')}.map do |d|
            j = {:uuid => (uuids[d] ||= uuid_from_id(d)), :name => d.name}
            "    #{j.to_json}"
          end*",\n"
        }\n  ],"

        object_types = @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}
        puts "  object_types: [\n#{
          object_types.sort_by{|o|o.identifying_role_values.inspect}.map do |o|
            uuids[o] ||= uuid_from_id(o)
            ref_mode = nil
            if o.is_a?(ActiveFacts::Metamodel::EntityType) and
              p = o.preferred_identifier and
              (rrs = p.role_sequence.all_role_ref).size == 1 and
              (r = rrs.single.role).fact_type != o.fact_type and
              r.object_type.is_a?(ActiveFacts::Metamodel::ValueType) and
              !r.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
              ref_mode = "#{r.object_type.name}"
              ref_mode.sub!(%r{#{o.name} *}, '.')
            end
            j = {
              :uuid => uuids[o],
              :name => o.name,
              :shapes => o.all_object_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
                x = { :diagram => uuids[shape.orm_diagram],
                  :is_expanded => shape.is_expanded,
                  :uuid => uuid_from_id(shape),
                  :x => shape.location.x,
                  :y => shape.location.y
                }
                x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
                x
              end
            }
            j[:ref_mode] = ref_mode if ref_mode
            j[:independent] = true if o.is_independent

            if o.is_a?(ActiveFacts::Metamodel::EntityType)
              # Entity Type may be objectified, and may have supertypes:
              if o.fact_type
                uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
                j[:objectifies] = uuid
                j[:implicit] = true if o.concept.implication_rule
              end
              if o.all_type_inheritance_as_subtype.size > 0
                j[:supertypes] = o.
                  all_type_inheritance_as_subtype.
                  sort_by{|ti| ti.provides_identification ? 0 : 1}.
                  map{|ti|
                    [ uuids[ti.supertype] ||= uuid_from_id(ti.supertype),
                      uuids[ti.supertype_role] = uuid_from_id(ti.supertype_role)
                    ]
                  }
              end
            else
              # ValueType usually has a supertype:
              if (o.supertype)
                j[:supertype] = (uuids[o.supertype] ||= uuid_from_id(o.supertype))
              end
            end
            # REVISIT: Place a ValueConstraint and shape
            "    #{j.to_json}"
          end*",\n"
        }\n  ],"

        fact_types = @vocabulary.constellation.
          FactType.values.
          reject{|ft|
            ActiveFacts::Metamodel::LinkFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
          }
        puts "  fact_types: [\n#{
          fact_types.sort_by{|f| f.identifying_role_values.inspect}.map do |f|
            uuids[f] ||= uuid_from_id(f)
            j = {:uuid => uuids[f]}

            if f.entity_type
              j[:objectified_as] = uuids[f.entity_type]
            end

            # Emit roles
            roles = f.all_role.sort_by{|r| r.ordinal }
            j[:roles] = roles.map do |role|
              uuid = (uuids[role] ||= uuid_from_id(role))
              # REVISIT: Internal Mandatory Constraints
              # REVISIT: Place a ValueConstraint and shape
              # REVISIT: Place a RoleName shape
              {:uuid => uuid, :player => uuids[role.object_type]}
              # N.B. The object_type shape to which this role is attached is not in the meta-model
              # Attach to the closest instance on this diagram (if any)
            end

            # Emit readings. Each is a [role_order, text] pair
            j[:readings] = f.all_reading.map do |r|
              role_refs = r.role_sequence.all_role_ref_in_order
              [
                role_order(uuids, role_refs.map{|rr| rr.role}, roles),
                r.text.gsub(/\{([0-9])\}/) do |insert|
                  role_ref = role_refs[$1.to_i]
                  la = role_ref.leading_adjective
                  la = nil if la == ''
                  ta = role_ref.trailing_adjective
                  ta = nil if ta == ''
                  (la ? la+'-' : '') +
                    (la && la.index(' ') ? ' ' : '') +
                    insert +
                    (ta && ta.index(' ') ? ' ' : '') +
                    (ta ? '-'+ta : '')
                end
              ]
            end.sort_by{|(ro,text)| ro }.map do |(ro,text)|
              [ ro, text ]
            end

            # Emit shapes
            j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
              sj = {
                :diagram => uuids[shape.orm_diagram],
                :uuid => uuid_from_id(shape),
                :x => shape.location.x,
                :y => shape.location.y
              }

              # Add the role_order, if specified
              if shape.all_role_display.size > 0
                if shape.all_role_display.size != roles.size
                  raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.orm_diagram.name} diagram"
                end
                ro = role_order(
                  uuids,
                  shape.all_role_display.sort_by{|rd| rd.ordinal }.map{|rd| rd.role },
                  roles
                )
                sj[:role_order] = ro if ro
              end

              # REVISIT: Place the ReadingShape

              # Emit the location of the name, if objectified
              if n = shape.objectified_fact_type_name_shape
                sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
              end
              sj
            end

            # Emit Internal Presence Constraints
            f.internal_presence_constraints.to_a.sort_by{|ipc, z|
		  [ipc.is_preferred_identifier ? 0 : 1, ipc.is_mandatory ? 0 : 1, ipc.min_frequency || 0, ipc.max_frequency || 1_000]
		}.each do |ipc|
              uuid = (uuids[ipc] ||= uuid_from_id(ipc))

              constraint = {
                :uuid => uuid,
                :min => ipc.min_frequency,
                :max => ipc.max_frequency,
                :is_preferred => ipc.is_preferred_identifier,
                :mandatory => ipc.is_mandatory
              }

              # Get the role (or excluded role, for a UC)
              roles = ipc.role_sequence.all_role_ref_in_order.map{|r| r.role}
              if roles.size > 1 || (!ipc.is_mandatory && ipc.max_frequency == 1)
                # This can be only a uniqueness constraint. Record the missing role, if any
                role = (f.all_role.to_a - roles)[0]
                constraint[:uniqueExcept] = uuids[role]
              else
                # An internal mandatory or frequency constraint applies to only one role.
                # If it's also unique (max == 1), that applies on the counterpart role.
                # You can also have a mandatory frequency constraint, but that applies on this role.
                constraint[:role] = uuids[roles[0]]
              end
              (j[:constraints] ||= []) << constraint
            end

            # Add ring constraints
            f.all_role_in_order.
              map{|r| r.all_ring_constraint.to_a+r.all_ring_constraint_as_other_role.to_a }.
              flatten.uniq.each do |ring|
                (j[:constraints] ||= []) << {
                    :uuid => (uuids[ring] ||= uuid_from_id(ring)),
                    :shapes => ring.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
                      { :diagram => uuids[shape.orm_diagram],
                        :uuid => uuid_from_id(shape),
                        :x => shape.location.x,
                        :y => shape.location.y
                      }
                    end,
                    :ringKind => ring.ring_type,
                    :roles => [uuids[ring.role], uuids[ring.other_role]]
                    # REVISIT: Deontic, enforcement
                  }
              end

            # REVISIT: RotationSetting

            "    #{j.to_json}"
          end*",\n"
        }\n  ],"

        constraints = @vocabulary.constellation.
          Constraint.values
        puts "  constraints: [\n#{
          constraints.sort_by{|c|c.identifying_role_values.inspect}.select{|c| !uuids[c]}.map do |c|
            uuid = uuids[c] ||= uuid_from_id(c)
            j = {
              :uuid => uuid,
              :type => c.class.basename,
              :shapes => c.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
                { :diagram => uuids[shape.orm_diagram],
                  :uuid => uuid_from_id(shape),
                  :x => shape.location.x,
                  :y => shape.location.y
                }
              end
            }

            if (c.enforcement)
              # REVISIT: Deontic constraint
            end
            if (c.concept.all_context_note_as_relevant_concept.size > 0)
              # REVISIT: Context Notes
            end

            case c
            when ActiveFacts::Metamodel::PresenceConstraint
              j[:min_frequency] = c.min_frequency
              j[:max_frequency] = c.max_frequency
              j[:is_mandatory] = c.is_mandatory
              j[:is_preferred_identifier] = c.is_preferred_identifier
              rss = [c.role_sequence.all_role_ref_in_order.map(&:role)]

              # Ignore internal presence constraints on TypeInheritance fact types
              next nil if !c.role_sequence.all_role_ref.
                detect{|rr|
                  !rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
                }

            when ActiveFacts::Metamodel::RingConstraint
              next nil  # These are emitted with the corresponding fact type

            when ActiveFacts::Metamodel::SetComparisonConstraint
              rss = c.
                all_set_comparison_roles.sort_by{|scr| scr.ordinal}.
                map{|scr| scr.role_sequence.all_role_ref_in_order.map(&:role) }
              if (ActiveFacts::Metamodel::SetExclusionConstraint === c)
                j[:is_mandatory] = c.is_mandatory
              end

            when ActiveFacts::Metamodel::SubsetConstraint
              rss = [c.subset_role_sequence, c.superset_role_sequence].
                map{|rs| rs.all_role_ref_in_order.map(&:role) }

            when ActiveFacts::Metamodel::ValueConstraint
              next nil  # REVISIT: Should have been handled elsewhere
              if (c.role)
                # Should have been handled as role.role_value_constraint
              elsif (c.value_type)
                # Should have been handled as object_type.value_constraint
              end
              j[:allowed_ranges] = c.all_allowed_range.map{|ar|
                [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].
                  map{|b| [b.value.literal, b.value.unit.name, b.is_inclusive] }
              }

            else
              raise "REVISIT: Constraint type not yet dumped to JSON"
            end

            # rss contains the constrained role sequences; map to uuids
            j[:role_sequences] = rss.map{|rs|
              rs.map do |role|
                uuids[role]
              end
            }

            "    #{j.to_json}"
          end.compact*",\n"
        }\n  ]"

        puts "}"
      end

      def role_order(uuids, roles, order)
        if (roles.size > 9)
          roles.map{|r| uuids[r] }
        else
          roles.map{|r| order.index(r).to_s }*''
        end
      end

      def uuid_from_id o
        irvs = o.identifying_role_values.inspect
        d = Digest::SHA1.digest irvs
        # $stderr.puts "#{o.class.basename}: #{irvs}"
        d[0,4].unpack("H8")[0]+'-'+
          d[4,2].unpack("H4")[0]+'-'+
          d[6,2].unpack("H4")[0]+'-'+
          d[8,2].unpack("H4")[0]+'-'+
          d[10,6].unpack("H6")[0]
      end

    end
  end
end

ActiveFacts::Registry.generator('json', ActiveFacts::Generate::JSON)