#!/usr/bin/env/python

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

import logging

from apache_atlas.model.enums import *
from apache_atlas.model.misc  import *
from apache_atlas.utils       import *


LOG = logging.getLogger('apache_atlas')


class AtlasBaseTypeDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.category    = attrs.get('category')
        self.guid        = attrs.get('guid')
        self.createdBy   = attrs.get('createdBy')
        self.updatedBy   = attrs.get('updatedBy')
        self.createTime  = attrs.get('createTime')
        self.updateTime  = attrs.get('updateTime')
        self.version     = attrs.get('version')
        self.name        = attrs.get('name')
        self.description = attrs.get('description')
        self.typeVersion = attrs.get('typeVersion')
        self.serviceType = attrs.get('serviceType')
        self.options     = attrs.get('options')


class AtlasEnumDef(AtlasBaseTypeDef):
    def __init__(self, attrs={}):
        AtlasBaseTypeDef.__init__(self, attrs)

        self.elementDefs  = attrs.get('elementDefs')
        self.defaultValue = attrs.get('defaultValue')

    def type_coerce_attrs(self):
        super(AtlasEnumDef, self).type_coerce_attrs()

        self.elementDefs = type_coerce_list(self.elementDefs, AtlasEnumElementDef)


class AtlasStructDef(AtlasBaseTypeDef):
    def __init__(self, attrs={}):
        AtlasBaseTypeDef.__init__(self, attrs)

        self.category      = non_null(attrs.get('category'), TypeCategory.STRUCT.name)
        self.attributeDefs = attrs.get('attributeDefs')

    def type_coerce_attrs(self):
        super(AtlasStructDef, self).type_coerce_attrs()

        self.attributeDefs = type_coerce_list(self.attributeDefs, AtlasAttributeDef)


class AtlasClassificationDef(AtlasStructDef):
    def __init__(self, attrs={}):
        AtlasStructDef.__init__(self, attrs)

        self.category    = TypeCategory.CLASSIFICATION.name
        self.superTypes  = attrs.get('superTypes')
        self.entityTypes = attrs.get('entityTypes')
        self.subTypes    = attrs.get('subTypes')


class AtlasEntityDef(AtlasStructDef):
    def __init__(self, attrs={}):
        AtlasStructDef.__init__(self, attrs)

        self.category                  = TypeCategory.ENTITY.name
        self.superTypes                = attrs.get('superTypes')
        self.subTypes                  = attrs.get('subTypes')
        self.relationshipAttributeDefs = attrs.get('relationshipAttributeDefs')
        self.businessAttributeDefs     = attrs.get('businessAttributeDefs')

    def type_coerce_attrs(self):
        super(AtlasEntityDef, self).type_coerce_attrs()

        self.relationshipAttributeDefs = type_coerce_list(self.relationshipAttributeDefs, AtlasRelationshipAttributeDef)
        self.businessAttributeDefs     = type_coerce_dict_list(self.businessAttributeDefs, AtlasAttributeDef)


class AtlasRelationshipDef(AtlasStructDef):
    def __init__(self, attrs={}):
        AtlasStructDef.__init__(self, attrs)

        self.category             = TypeCategory.RELATIONSHIP.name
        self.relationshipCategory = attrs.get('relationshipCategory');
        self.relationshipLabel    = attrs.get('relationshipLabel');
        self.propagateTags        = attrs.get('propagateTags');
        self.endDef1              = attrs.get('endDef1');
        self.endDef2              = attrs.get('endDef2');

    def type_coerce_attrs(self):
        super(AtlasRelationshipDef, self).type_coerce_attrs()

        self.endDef1 = type_coerce(self.endDef1, AtlasRelationshipEndDef)
        self.endDef2 = type_coerce(self.endDef2, AtlasRelationshipEndDef)


class AtlasBusinessMetadataDef(AtlasStructDef):
    def __init__(self, attrs={}):
        AtlasStructDef.__init__(self, attrs)

        self.category = TypeCategory.BUSINESS_METADATA.name


class AtlasAttributeDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.name                  = attrs.get('name')
        self.typeName              = attrs.get('typeName')
        self.isOptional            = attrs.get('isOptional')
        self.cardinality           = attrs.get('cardinality')
        self.valuesMinCount        = attrs.get('valuesMinCount')
        self.valuesMaxCount        = attrs.get('valuesMaxCount')
        self.isUnique              = attrs.get('isUnique')
        self.isIndexable           = attrs.get('isIndexable')
        self.includeInNotification = attrs.get('includeInNotification')
        self.defaultValue          = attrs.get('defaultValue')
        self.description           = attrs.get('description')
        self.searchWeight          = non_null(attrs.get('searchWeight'), -1)
        self.indexType             = attrs.get('indexType')
        self.constraints           = attrs.get('constraints')
        self.options               = attrs.get('options')
        self.displayName           = attrs.get('displayName')

    def type_coerce_attrs(self):
        super(AtlasAttributeDef, self).type_coerce_attrs()

        self.constraints = type_coerce_list(self.constraints, AtlasConstraintDef)


class AtlasConstraintDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.type   = attrs.get('type')
        self.params = attrs.get('params')


class AtlasEnumElementDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.value       = attrs.get('value')
        self.description = attrs.get('description')
        self.ordinal     = attrs.get('ordinal')


class AtlasRelationshipAttributeDef(AtlasAttributeDef):
    def __init__(self, attrs={}):
        AtlasAttributeDef.__init__(self, attrs)

        self.relationshipTypeName = attrs.get('relationshipTypeName')
        self.isLegacyAttribute    = attrs.get('isLegacyAttribute')


class AtlasRelationshipEndDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.type              = attrs.get('type')
        self.name              = attrs.get('name')
        self.isContainer       = attrs.get('isContainer')
        self.cardinality       = attrs.get('cardinality')
        self.isLegacyAttribute = attrs.get('isLegacyAttribute')
        self.description       = attrs.get('description')


class AtlasTypesDef(AtlasBase):
    def __init__(self, attrs={}):
        AtlasBase.__init__(self, attrs)

        self.enumDefs             = attrs.get('enumDefs')
        self.structDefs           = attrs.get('structDefs')
        self.classificationDefs   = attrs.get('classificationDefs')
        self.entityDefs           = attrs.get('entityDefs')
        self.relationshipDefs     = attrs.get('relationshipDefs')
        self.businessMetadataDefs = attrs.get('businessMetadataDefs')

    def type_coerce_attrs(self):
        super(AtlasTypesDef, self).type_coerce_attrs()

        self.enumDefs             = type_coerce_list(self.enumDefs, AtlasEnumDef)
        self.structDefs           = type_coerce_list(self.structDefs, AtlasStructDef)
        self.classificationDefs   = type_coerce_list(self.classificationDefs, AtlasClassificationDef)
        self.entityDefs           = type_coerce_list(self.entityDefs, AtlasEntityDef)
        self.relationshipDefs     = type_coerce_list(self.relationshipDefs, AtlasRelationshipDef)
        self.businessMetadataDefs = type_coerce_list(self.businessMetadataDefs, AtlasBusinessMetadataDef)


