# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models, migrations
import jsonfield.fields


class Migration(migrations.Migration):

    dependencies = [
        ('account', '0012_auto_20160627_1419'),
    ]

    operations = [
        migrations.CreateModel(
            name='WechatInfo',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('status', models.BooleanField(default=True, help_text='\u72b6\u6001', db_index=True, verbose_name='status')),
                ('created_at', models.DateTimeField(help_text='\u521b\u5efa\u65f6\u95f4', verbose_name='created_at', auto_now_add=True)),
                ('updated_at', models.DateTimeField(help_text='\u66f4\u65b0\u65f6\u95f4', verbose_name='updated_at', auto_now=True)),
                ('unionid', models.CharField(help_text='\u5fae\u4fe1 Union ID', max_length=255, null=True, verbose_name='unionid', blank=True)),
                ('openids', jsonfield.fields.JSONField(help_text='\u5fae\u4fe1 Open IDs', null=True, verbose_name='openids', blank=True)),
                ('sex', models.IntegerField(default=1, help_text='\u7528\u6237\u6027\u522b', verbose_name='sex', choices=[(1, '\u7537'), (0, '\u5973')])),
                ('nickname', models.CharField(help_text='\u7528\u6237\u6635\u79f0', max_length=255, null=True, verbose_name='nickname', blank=True)),
                ('headimgurl', models.CharField(help_text='\u7528\u6237\u5934\u50cf', max_length=255, null=True, verbose_name='headimgurl', blank=True)),
                ('country', models.CharField(help_text='\u7528\u6237\u56fd\u5bb6', max_length=255, null=True, verbose_name='country', blank=True)),
                ('province', models.CharField(help_text='\u7528\u6237\u7701\u4efd', max_length=255, null=True, verbose_name='province', blank=True)),
                ('city', models.CharField(help_text='\u7528\u6237\u57ce\u5e02', max_length=255, null=True, verbose_name='city', blank=True)),
                ('location', models.CharField(help_text='\u7528\u6237\u5730\u5740', max_length=255, null=True, verbose_name='location', blank=True)),
            ],
            options={
                'verbose_name': 'wechatinfo',
                'verbose_name_plural': 'wechatinfo',
            },
        ),
        migrations.AddField(
            model_name='lensmaninfo',
            name='unionid',
            field=models.CharField(null=True, max_length=255, blank=True, help_text='\u5fae\u4fe1 Union ID', unique=True, verbose_name='unionid', db_index=True),
        ),
        migrations.AddField(
            model_name='lensmaninfo',
            name='user_status',
            field=models.IntegerField(default=0, verbose_name='user_status', choices=[(0, '\u672a\u9a8c\u8bc1'), (1, '\u5df2\u6fc0\u6d3b'), (2, '\u5df2\u7981\u7528'), (3, '\u5df2\u5220\u9664'), (10, '\u5df2\u5206\u914d')]),
        ),
        migrations.AlterField(
            model_name='userinfo',
            name='unionid',
            field=models.CharField(null=True, max_length=255, blank=True, help_text='\u5fae\u4fe1 Union ID', unique=True, verbose_name='unionid', db_index=True),
        ),
    ]

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

from __future__ import division

from django.conf import settings
from django.contrib.auth.hashers import check_password
from django.db import transaction
from django_logit import logit
from django_response import response
from pywe_miniapp import get_phone_number
from pywe_storage import RedisStorage
from TimeConvert import TimeConvert as tc

from account.models import UserInfo
from mch.models import (ActivityInfo, AdministratorInfo, BrandInfo, ConsumeInfoSubmitLogInfo, DistributorInfo,
                        LatestAppInfo, LatestAppScreenInfo, ModelInfo, OperatorInfo)
from statistic.models import ConsumeModelSaleStatisticInfo, ConsumeSaleStatisticInfo, ConsumeUserStatisticInfo
from utils.error.errno_utils import (AdministratorStatusCode, OperatorStatusCode, ProductBrandStatusCode,
                                     ProductModelStatusCode, UserStatusCode)
from utils.redis.connect import r
from utils.redis.rkeys import MINI_PROGRAM_GIS_LIST


WECHAT = settings.WECHAT


@logit
def optor_login_api(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    phone = request.POST.get('phone', '')
    password = request.POST.get('password', '')

    try:
        operator = OperatorInfo.objects.get(phone=phone, status=True)
    except OperatorInfo.DoesNotExist:
        return response(OperatorStatusCode.OPERATOR_NOT_FOUND)

    if operator.user_status == OperatorInfo.DISABLED:
        return response(OperatorStatusCode.OPERATOR_NOT_ACTIVATED)
    elif operator.user_status == OperatorInfo.DELETED:
        return response(OperatorStatusCode.OPERATOR_HAS_DELETED)

    if not check_password(password, operator.encryption):
        return response(OperatorStatusCode.OPERATOR_PASSWORD_ERROR)

    return response(200, 'Optor Login Success', u'操作员登录成功', data=operator.kododata)


@logit
def admin_login_api(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    phone = request.POST.get('phone', '')
    password = request.POST.get('password', '')

    try:
        administrator = AdministratorInfo.objects.get(phone=phone, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    if administrator.user_status == AdministratorInfo.DISABLED:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_ACTIVATED)
    elif administrator.user_status == AdministratorInfo.DELETED:
        return response(AdministratorStatusCode.ADMINISTRATOR_HAS_DELETED)

    if not check_password(password, administrator.encryption):
        return response(AdministratorStatusCode.ADMINISTRATOR_PASSWORD_ERROR)

    request.session['admin_id'] = administrator.admin_id

    return response(200, 'Admin Login Success', u'管理员登录成功', data={
        'admin_id': administrator.admin_id,
        'admin_type': administrator.admin_type,
        'qrurl': settings.KODO_CLERK_AUTH_URL.format(administrator.brand_id),
    })


@logit
def bmd_infos(request):
    optor_id = request.POST.get('optor_id', '')

    try:
        operator = OperatorInfo.objects.get(operator_id=optor_id, status=True)
    except OperatorInfo.DoesNotExist:
        return response(OperatorStatusCode.OPERATOR_NOT_FOUND)

    if operator.user_status == OperatorInfo.DISABLED:
        return response(OperatorStatusCode.OPERATOR_NOT_ACTIVATED)

    brands = BrandInfo.objects.filter(brand_id=operator.brand_id, status=True).order_by('position')
    brands = [brand.data for brand in brands]

    tmpmodels = ModelInfo.objects.filter(brand_id=operator.brand_id, display=True, status=True).order_by('position')
    models = [model.data for model in tmpmodels]
    # jancodes = {model.jancode: model.data for model in tmpmodels}

    distributors = DistributorInfo.objects.filter(brand_id=operator.brand_id, status=True).order_by('position')
    distributors = [distributor.data for distributor in distributors]

    return response(200, data={
        'optor_id': operator.operator_id,
        'brands': brands,
        'models': models,
        # 'jancodes': jancodes,
        'distributors': distributors,
    })


@logit
def brands_list(request):
    brands = BrandInfo.objects.filter(status=True).order_by('position')
    brands = [brand.data for brand in brands]

    return response(200, data={
        'brands': brands,
    })


@logit
def models_list(request):
    models = ModelInfo.objects.filter(status=True).order_by('position')
    models = [model.data for model in models]

    return response(200, data={
        'models': models,
    })


@logit
def distributors_list(request):
    distributors = DistributorInfo.objects.filter(status=True).order_by('position')
    distributors = [distributor.data for distributor in distributors]

    return response(200, data={
        'distributors': distributors,
    })


@logit
def upgrade_api(request):
    """ APP 升级 """
    src = request.POST.get('src', '')

    if src == 'datascreen':
        latestappmodel = LatestAppScreenInfo
    else:
        latestappmodel = LatestAppInfo

    try:
        appinfo = latestappmodel.objects.filter(status=True)[0].adr
    except IndexError:
        appinfo = {
            'latest_version_code': '',
            'latest_version_name': '',
            'latest_url': '',
        }

    return response(200, 'Get Latest App Success', u'获取最新版信息成功', {
        'appinfo': appinfo,
    })


def getPhoneNumber(request):
    user_id = request.POST.get('user_id', '')

    wxcfg = WECHAT.get('MINIAPP', {})

    appid = wxcfg.get('appID')

    # Just for compatible because of store session_key has changed
    session_key = None if user_id else RedisStorage(r).get('{0}:{1}:sessionKey'.format(appid, ''))

    wxcfg = WECHAT.get('MINIAPP', {})

    appid = wxcfg.get('appID')
    secret = wxcfg.get('appsecret')

    iv = request.POST.get('iv', '')
    encryptedData = request.POST.get('encryptedData', '')

    # {
    #     "phoneNumber": "13580006666",
    #     "purePhoneNumber": "13580006666",
    #     "countryCode": "86",
    #     "watermark":
    #         {
    #             "appid": "APPID",
    #             "timestamp": TIMESTAMP
    #         }
    # }
    phone_number = get_phone_number(appid=appid, secret=secret, unid=user_id, session_key=session_key, encryptedData=encryptedData, iv=iv, storage=RedisStorage(r))

    return phone_number.get('purePhoneNumber', '')


@logit(res=True)
def consumer_phone_api(request):
    return response(200, 'Get Consumer Phone Success', u'获取消费者手机号成功', {
        'purePhoneNumber': getPhoneNumber(request),
    })


@logit(res=True)
@transaction.atomic
def consumer_info_api(request):
    user_id = request.POST.get('user_id', '')
    iv = request.POST.get('iv', '')
    encryptedData = request.POST.get('encryptedData', '')
    lat = request.POST.get('lat', .0)
    lon = request.POST.get('lon', .0)
    brandID = request.POST.get('BrandID', '')
    modelID = request.POST.get('ModelID', '')
    distributorID = request.POST.get('DistributorID', '')
    serialNo = request.POST.get('SerialNo', '')
    verifyResult = request.POST.get('verifyResult', '')
    purePhoneNumber = request.POST.get('purePhoneNumber', '')

    if lat == 'undefined':
        lat = .0
    if lon == 'undefined':
        lon = .0

    purePhoneNumber = purePhoneNumber or getPhoneNumber(request)

    # 校验用户是否存在
    try:
        user = UserInfo.objects.get(user_id=user_id)
    except UserInfo.DoesNotExist:
        return response(UserStatusCode.USER_NOT_FOUND)

    # 更新用户手机号
    user.phone = purePhoneNumber
    user.save()

    try:
        brand = BrandInfo.objects.get(pk=brandID)
    except BrandInfo.DoesNotExist:
        brand = None
    except ValueError:
        brand = None

    if not brand:
        try:
            brand = BrandInfo.objects.get(brand_id=brandID)
        except BrandInfo.DoesNotExist:
            return response(ProductBrandStatusCode.BRAND_NOT_FOUND)

    try:
        model = ModelInfo.objects.get(pk=modelID)
    except ModelInfo.DoesNotExist:
        return response(ProductModelStatusCode.MODEL_NOT_FOUND)
    except ValueError:
        return response(ProductModelStatusCode.MODEL_NOT_FOUND)

    # try:
    #     distributor = DistributorInfo.objects.get(pk=distributorID)
    # except DistributorInfo.DoesNotExist:
    #     return response(ProductDistributorStatusCode.DISTRIBUTOR_NOT_FOUND)
    # except ValueError:
    #     return response(ProductDistributorStatusCode.DISTRIBUTOR_NOT_FOUND)

    dupload = ConsumeInfoSubmitLogInfo.objects.filter(
        brand_id=brand.brand_id,
        model_id=model.model_id,
        # distributor_id=distributor.distributor_id,
        distributor_id='',
        serialNo=serialNo,
        verifyResult=1,
        test_user=False,
    ).exists()

    if dupload:
        act = None
        during_activity = False
    else:
        act = ActivityInfo.objects.filter(status=True).order_by('-pk').first()
        during_activity = True if act and act.has_unexpired_activity(model.model_uni_name) else False

    # 记录用户信息提交记录
    log = ConsumeInfoSubmitLogInfo.objects.create(
        user_id=user_id,
        phone=purePhoneNumber,
        iv=iv,
        encryptedData=encryptedData,
        lat=lat,
        lon=lon,
        brand_id=brand.brand_id,
        brand_name=brand.brand_name,
        model_id=model.model_id,
        model_name=model.model_name,
        # distributor_id=distributor.distributor_id,
        # distributor_name=distributor.distributor_name,
        distributor_id='',
        distributor_name='',
        serialNo=serialNo,
        verifyResult=verifyResult,
        dupload=dupload,
        submit_during_activity=during_activity,
        activity_id=act.pk if during_activity else 0,
        coupon_expire_at=act.coupon_expire_at if during_activity else None,
        coupon_value=act.coupon_value if during_activity else 0,
        test_user=user.test_user,
    )

    if not user.test_user and not dupload:
        # TODO: Make statistic async
        ymd = tc.local_string(format='%Y%m%d')

        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd,
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()
        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:6],
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()
        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:4],
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()

        # 日销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd,
        )
        cssi.num += 1
        cssi.save()
        # 月销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:6],
        )
        cssi.num += 1
        cssi.save()
        # 年销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:4],
        )
        cssi.num += 1
        cssi.save()

        # 日型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd,
        )
        cmssi.num += 1
        cmssi.save()
        # 月型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd[:6],
        )
        cmssi.num += 1
        cmssi.save()
        # 年型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd[:4],
        )
        cmssi.num += 1
        cmssi.save()

        r.rpushjson(MINI_PROGRAM_GIS_LIST, {
            'brand_id': log.brand_id,
            'user_id': log.user_id,
            'lat': log.lat,
            'lon': log.lon,
            'phone': log.phone,
            'ymd': ymd,
        })

    return response(200, 'Submit Consumer Info Success', u'提交消费者信息成功')


@logit(res=True)
@transaction.atomic
def consumer_snlist_api(request):
    user_id = request.POST.get('user_id', '')

    # 校验用户是否存在
    try:
        user = UserInfo.objects.get(user_id=user_id)
    except UserInfo.DoesNotExist:
        return response(UserStatusCode.USER_NOT_FOUND)

    # 用户信息提交列表
    logs = ConsumeInfoSubmitLogInfo.objects.filter(user_id=user_id, status=True).distinct()
    seen = set()
    seen_add = seen.add
    logs = [log.data for log in logs if not (log.serialNo in seen or seen_add(log.serialNo))]

    return response(200, 'Get Consumer Submit List Success', u'获取消费者提交列表成功', {
        'logs': logs,
    })