# -*- coding: utf-8 -*-

# Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
#
# 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.

import sqlalchemy as sa
import logging
import hashlib

from datetime import datetime
from appenlight.models import Base
from appenlight.lib.utils import convert_es_type
from appenlight.lib.enums import LogLevel
from sqlalchemy.dialects.postgresql import JSON
from ziggurat_foundations.models.base import BaseModel

log = logging.getLogger(__name__)


class Log(Base, BaseModel):
    __tablename__ = 'logs'
    __table_args__ = {'implicit_returning': False}

    log_id = sa.Column(sa.BigInteger(), nullable=False, primary_key=True)
    resource_id = sa.Column(sa.Integer(),
                            sa.ForeignKey('applications.resource_id',
                                          onupdate='CASCADE',
                                          ondelete='CASCADE'),
                            nullable=False,
                            index=True)
    log_level = sa.Column(sa.Unicode, nullable=False, index=True,
                          default='INFO')
    message = sa.Column(sa.UnicodeText(), default='')
    timestamp = sa.Column(sa.DateTime(), default=datetime.utcnow,
                          server_default=sa.func.now())
    request_id = sa.Column(sa.Unicode())
    namespace = sa.Column(sa.Unicode())
    primary_key = sa.Column(sa.Unicode())

    tags = sa.Column(JSON(), default={})
    permanent = sa.Column(sa.Boolean(), nullable=False, default=False)

    def __str__(self):
        return self.__unicode__().encode('utf8')

    def __unicode__(self):
        return '<Log id:%s, lv:%s, ns:%s >' % (
            self.log_id, self.log_level, self.namespace)

    def set_data(self, data, resource):
        level = data.get('log_level').upper()
        self.log_level = getattr(LogLevel, level, LogLevel.UNKNOWN)
        self.message = data.get('message', '')
        server_name = data.get('server', '').lower() or 'unknown'
        self.tags = {
            'server_name': server_name
        }
        if data.get('tags'):
            for tag_tuple in data['tags']:
                self.tags[tag_tuple[0]] = tag_tuple[1]
        self.timestamp = data['date']
        r_id = data.get('request_id', '')
        if not r_id:
            r_id = ''
        self.request_id = r_id.replace('-', '')
        self.resource_id = resource.resource_id
        self.namespace = data.get('namespace') or ''
        self.permanent = data.get('permanent')
        self.primary_key = data.get('primary_key')
        if self.primary_key is not None:
            self.tags['appenlight_primary_key'] = self.primary_key

    def get_dict(self):
        instance_dict = super(Log, self).get_dict()
        instance_dict['log_level'] = LogLevel.key_from_value(self.log_level)
        instance_dict['resource_name'] = self.application.resource_name
        return instance_dict

    @property
    def delete_hash(self):
        if not self.primary_key:
            return None

        to_hash = '{}_{}_{}'.format(self.resource_id, self.primary_key,
                                    self.namespace)
        return hashlib.sha1(to_hash.encode('utf8')).hexdigest()

    def es_doc(self):
        tags = {}
        tag_list = []
        for name, value in self.tags.items():
            # replace dot in indexed tag name
            name = name.replace('.', '_')
            tag_list.append(name)
            tags[name] = {
                "values": convert_es_type(value),
                "numeric_values": value if (
                    isinstance(value, (int, float)) and
                    not isinstance(value, bool)) else None
            }
        return {
            'pg_id': str(self.log_id),
            'delete_hash': self.delete_hash,
            'resource_id': self.resource_id,
            'request_id': self.request_id,
            'log_level': LogLevel.key_from_value(self.log_level),
            'timestamp': self.timestamp,
            'message': self.message if self.message else '',
            'namespace': self.namespace if self.namespace else '',
            'tags': tags,
            'tag_list': tag_list
        }

    @property
    def partition_id(self):
        if self.permanent:
            return 'rcae_l_%s' % self.timestamp.strftime('%Y_%m')
        else:
            return 'rcae_l_%s' % self.timestamp.strftime('%Y_%m_%d')