#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
import pymorphy2
from trademark.models import Trademark, Product, Nice
from django.http import HttpResponse
import json


def _get_random_list(qs):

    _list = list(qs)
    random.shuffle(_list)

    return _list


def _get_dic_words(words):

    words_dict = {}

    for key in words:
        key = key.lower()
        if key in words_dict:
            value = words_dict[key]
            words_dict[key] = value + 1
        else:
            words_dict[key] = 1

    return words_dict


def get_notation(list_words, normalize=False, t=0):

    if t:
        print 't', list_words

    if len(list_words) > 1:
        notation = list_words[random.randint(0, len(list_words) - 1)]
    else:
        notation = list_words[0]

    if normalize:
        print 'normalize 44', notation, notation[0], notation[1]

        morph = pymorphy2.MorphAnalyzer().parse(notation[0])[0]
        try:
            result = morph.inflect({'plur', 'nomn'}).word, notation[1]
        except:
            result = get_notation(list_words, normalize=True, t=1)
    else:
        # print notation
        result = notation[0], notation[1]

    result = result[0].capitalize(), result[1]

    return result


def get_lists_for_notation(trademark):

    _words = []
    _generic_words = []

    morph = pymorphy2.MorphAnalyzer()

    try:
        products = trademark.products.all()
        for product in products:
            if product:
                nice_id = product.nice_id
                product_phrase = product.title.split(',')

                for phrase in product_phrase:
                    words = phrase.\
                        lower().\
                        replace(';', '').\
                        replace('.', '').\
                        replace('[', '').\
                        replace(']', ''). \
                        replace('(', ''). \
                        replace(')', ''). \
                        replace('\n', '')

                    if len(words.split()) == 1:
                        _words.append((words.replace(' ', ''), nice_id))

                    fraction_phrase = words.lower().split(' ')
                    for word in fraction_phrase:
                        p = morph.parse(word)[0]
                        if len(word) >= 3 and p.tag.POS == 'NOUN':
                            _generic_words.append((p.normal_form, nice_id))

    except Product.DoesNotExist:
        return False, False
    return _words, _generic_words


def get_random_list_trademarks(request, status='Expired', count=10):
    ico = ''
    notation = ''
    trademark_list = []

    expired_trademarks = Trademark.objects.filter(status=status)
    random_list = _get_random_list(expired_trademarks)[:count]

    for trademark in random_list:
        words, generic_words = get_lists_for_notation(trademark)

        if words:
            notation = get_notation(words)
            # print 'words', notation, notation[1]
        if not words and generic_words:
            # print generic_words
            notation = get_notation(generic_words, normalize=True)
            # print 'generic_words', notation, notation[0], notation[1]
        if notation:
            brand = u'{notation} "{title} "'.format(notation=notation[0], title=trademark)
            # print u'%s' % notation[0] + u' "%s"' % trademark
            try:
                pass
                # print notation[1]
                # print notation
                ico = Nice.objects.get(nice_id=notation[1]).glyph
            except Nice.DoesNotExist:
                ico = 'fa-snowflake-o'
        else:
            brand = u'{}'.format(trademark)

        trademark_list.append({'name': brand,
                               'ico': u'fa {}'.format(ico)
                               })

    response = {'count': len(trademark_list), 'status': 'ok', 'items': trademark_list}

    return HttpResponse(json.dumps(response), content_type="application/json")