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

import os
import random

import shortuuid
from curtail_uuid import CurtailUUID
from django.conf import settings
from django.core.files.storage import default_storage
from django.db import connection, transaction
from django.http import JsonResponse
from django.shortcuts import render
from rest_framework import viewsets
from TimeConvert import TimeConvert as tc

from account.models import UserInfo
from group.models import (GroupInfo, GroupPhotoInfo, GroupUserInfo,
                          PhotoCommentInfo, PhotoThumbUpInfo)
from group.serializers import (GroupInfoSerializer, GroupPhotoInfoSerializer,
                               GroupUserInfoSerializer)
from message.models import UserMessageInfo
from utils.error.errno_utils import (GroupPhotoStatusCode, GroupStatusCode,
                                     GroupUserStatusCode, UserStatusCode)
from utils.error.response_utils import response
from utils.page_utils import pagination
from utils.redis.rgroup import (del_group_photo_thumbup_flag, get_group_info,
                                get_group_photo_thumbup_flag,
                                get_group_users_info, set_group_info,
                                set_group_photo_thumbup_flag,
                                set_group_users_info)
from utils.redis.rkeys import (GROUP_LAST_PHOTO_PK, GROUP_USERS_APPLYING_SET,
                               GROUP_USERS_DELETED_SET, GROUP_USERS_PASSED_SET,
                               GROUP_USERS_QUIT_SET, GROUP_USERS_REFUSED_SET,
                               LENSMAN_PHOTO_HAGGLE_TIMES, LENSMAN_PHOTO_PRICE)
from utils.redis.rorder import get_lensman_order_record
from utils.sql.raw import PAI2_HOME_API
from utils.thumbnail_utils import make_thumbnail
from utils.url_utils import img_url

r = settings.REDIS_CACHE


@transaction.atomic
def group_create_api(request):
    """
    群组创建
    :param request:
    :return:
    """
    user_id = request.POST.get('user_id', '')
    group_name = request.POST.get('group_name', '')
    group_default_avatar = int(request.POST.get('group_default_avatar', 0))

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

    # 群组唯一标识
    group_id = CurtailUUID.uuid(GroupInfo, 'group_id')

    # 群组记录创建
    group = GroupInfo.objects.create(
        group_id=group_id,
        admin_id=user_id,
        group_name=group_name,
        group_default_avatar=group_default_avatar,
        group_from=GroupInfo.APP_GROUP,
    )

    # Redis 群组数据缓存
    group_info = set_group_info(group)

    # 群组用户记录创建
    GroupUserInfo.objects.create(
        group_id=group_id,
        user_id=user_id,
        nickname=user.final_nickname,
        avatar=user.avatar,
        admin=True,
        user_status=GroupUserInfo.PASSED,
        passed_at=tc.utc_datetime(),
    )

    # Redis 群组用户数据缓存
    group_users = set_group_users_info(group)

    # Redis 群组通过集合缓存
    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'群组创建成功',
        'data': {
            'group_id': group_id,
            'group': group_info,
            'users': group_users,
        },
    })


def group_detail_api(request):
    """
    群组详情
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')

    return JsonResponse({
        'status': 200,
        'message': u'获取群组详情成功',
        'data': {
            'group_id': group_id,
            'group': get_group_info(group_id),
            'users': get_group_users_info(group_id, user_id),
        },
    })


def group_update_api(request):
    """
    群组更新
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '') or request.POST.get('user_id', '')
    group_name = request.POST.get('group_name', '')
    group_desc = request.POST.get('group_desc', '')

    group_avatar = request.FILES.get('group_avatar', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id:
        return response(GroupStatusCode.NO_UPDATE_PERMISSION)

    # 群组名称更新
    if group_name:
        group.group_name = group_name
    # 群组描述更新
    if group_desc:
        group.group_desc = group_desc
    # 群组头像更新
    if group_avatar:
        _, extension = os.path.splitext(group_avatar.name)
        group_avatar_path = 'group/{uuid}_{extension}'.format(uuid=shortuuid.uuid(), extension=extension)
        if default_storage.exists(group_avatar_path):
            default_storage.delete(group_avatar_path)
        default_storage.save(group_avatar_path, group_avatar)
        group.group_avatar = group_avatar_path
    group.save()

    # Redis 群组数据缓存更新
    group_info = set_group_info(group)

    return JsonResponse({
        'status': 200,
        'message': u'群组更新成功',
        'data': {
            'group_id': group_id,
            'group': group_info,
            'users': get_group_users_info(group_id, admin_id),
        },
    })


def group_list_api(request):
    """
    群组列表
    :param request:
    :return:
    """
    user_id = request.POST.get('user_id', '')
    page = int(request.POST.get('page', 1))
    num = int(request.POST.get('num', settings.GROUP_PER_PAGE))

    group_users = GroupUserInfo.objects.filter(user_id=user_id, user_status=GroupUserInfo.PASSED)
    group_users, left = pagination(group_users, page, num)

    groups = []
    for group_user in group_users:
        group_info = get_group_info(group_user.group_id)
        groups.append(group_info) if group_info else None

    return JsonResponse({
        'status': 200,
        'message': u'获取群组列表成功',
        'data': {
            'groups': groups,
            'left': left,
        },
    })


def group_join_api(request):
    """
    申请加群
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    nickname = request.POST.get('nickname', '')

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

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 群组锁定校验
    if group.group_lock:
        return response(GroupStatusCode.GROUP_HAS_LOCKED)

    # 群组用户记录创建，若记录不存在，则创建，若记录已存在，则更新
    group_user, created = GroupUserInfo.objects.get_or_create(
        group_id=group_id,
        user_id=user_id,
    )
    if group_user.user_status != GroupUserInfo.PASSED:
        group_user.current_id = int(r.get(GROUP_LAST_PHOTO_PK % group_id) or -1)
        group_user.nickname = nickname or user.final_nickname
        group_user.avatar = user.avatar
        # group_user.admin = False  # Admin Field Default False, Should Not Assign
        group_user.user_status = GroupUserInfo.PASSED
        group_user.passed_at = tc.utc_datetime()
        group_user.save()

    # Redis 群组用户数据缓存
    set_group_users_info(group)

    # Redis 群组通过集合缓存
    r.srem(GROUP_USERS_REFUSED_SET % group_id, user_id)
    r.srem(GROUP_USERS_DELETED_SET % group_id, user_id)
    r.srem(GROUP_USERS_QUIT_SET % group_id, user_id)
    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'申请成功',
        'data': {
            'current_id': group_user.current_id,
            'photos': [],
            'group_id': group_id,
            'group': get_group_info(group_id),
            'user_id': user_id,
            'users': get_group_users_info(group_id, user_id),
        },
    })


def group_lock_api(request):
    """
    群组锁定
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '') or request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id:
        return response(GroupStatusCode.NO_LOCK_PERMISSION)

    # 群组锁定
    group.group_lock = True
    group.save()

    # Redis 群组数据缓存更新
    set_group_info(group)

    return JsonResponse({
        'status': 200,
        'message': u'锁定成功',
    })


def group_unlock_api(request):
    """
    群组解锁
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '') or request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id:
        return response(GroupStatusCode.NO_UNLOCK_PERMISSION)

    # 群组解锁
    group.group_lock = False
    group.save()

    # Redis 群组数据缓存更新
    set_group_info(group)

    return JsonResponse({
        'status': 200,
        'message': u'解锁成功',
    })


def group_remove_api(request):
    """
    成员移除
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id or group.admin_id == user_id:  # 管理员也不允许将自己移除
        return response(GroupStatusCode.NO_REMOVE_PERMISSION)

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    # 群组用户移除
    group_user.user_status = GroupUserInfo.DELETED
    group_user.deleted_at = tc.utc_datetime()
    group_user.save()

    # Redis 群组数据缓存更新
    group_users = set_group_info(group)

    # Redis 群组删除集合缓存
    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
    r.sadd(GROUP_USERS_DELETED_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'用户移除成功',
        'data': {
            'group_id': group_id,
            'users': group_users,
        },
    })


def group_quit_api(request):
    """
    成员退出
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id == user_id:  # 管理员也不允许自己退出
        return response(GroupStatusCode.NO_QUIT_PERMISSION)

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    # 群组用户移除
    group_user.user_status = GroupUserInfo.QUIT
    group_user.quit_at = tc.utc_datetime()
    group_user.save()

    # Redis 群组数据缓存更新
    group_users = set_group_info(group)

    # Redis 群组删除集合缓存
    r.srem(GROUP_USERS_PASSED_SET % group_id, user_id)
    r.sadd(GROUP_USERS_QUIT_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'用户退出成功',
        'data': {
            'group_id': group_id,
            'users': group_users,
        },
    })


def group_pass_api(request):
    """
    申请通过
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id:
        return response(GroupStatusCode.NO_PASS_PERMISSION)

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
    except GroupUserInfo.DoesNotExist:
        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)

    # 群组用户通过
    group_user.user_status = GroupUserInfo.PASSED
    group_user.passed_at = tc.utc_datetime()
    group_user.save()

    # Redis 群组数据缓存更新
    group_users = set_group_info(group)

    # Redis 群组通过集合缓存
    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
    r.sadd(GROUP_USERS_PASSED_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'申请通过成功',
        'data': {
            'group_id': group_id,
            'users': group_users,
        },
    })


def group_refuse_api(request):
    """
    申请拒绝
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')

    # 群组校验
    try:
        group = GroupInfo.objects.get(group_id=group_id)
    except GroupInfo.DoesNotExist:
        return response(GroupStatusCode.GROUP_NOT_FOUND)

    # 权限校验
    if group.admin_id != admin_id:
        return response(GroupStatusCode.NO_REFUSE_PERMISSION)

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.APPLYING)
    except GroupUserInfo.DoesNotExist:
        return response(GroupStatusCode.JOIN_REQUEST_NOT_FOUND)

    # 群组用户拒绝
    group_user.user_status = GroupUserInfo.REFUSED
    group_user.refused_at = tc.utc_datetime()
    group_user.save()

    # Redis 群组数据缓存更新
    group_users = set_group_info(group)

    # Redis 群组拒绝集合缓存
    r.srem(GROUP_USERS_APPLYING_SET % group_id, user_id)
    r.sadd(GROUP_USERS_REFUSED_SET % group_id, user_id)

    return JsonResponse({
        'status': 200,
        'message': u'申请拒绝成功',
        'data': {
            'group_id': group_id,
            'users': group_users,
        },
    })


def flyimg_upload_api(request):
    """
    飞图上传／飞图列表
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    nickname = request.POST.get('nickname', '')

    photo = request.FILES.get('photo', '')

    current_id = int(request.POST.get('current_id', -1))

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

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    if photo:
        photo_path = 'fly/{uuid}{extension}'.format(uuid=shortuuid.uuid(), extension=os.path.splitext(photo.name)[1] or 'jpeg')
        photo_thumbnail_path = photo_path.replace('.', '_thumbnail.')
        photo_thumbnail2_path = photo_path.replace('.', '_thumbnail2.')

        if default_storage.exists(photo_path):
            default_storage.delete(photo_path)
        default_storage.save(photo_path, photo)

        # if default_storage.exists(photo_thumbnail_path):
        #     default_storage.delete(photo_thumbnail_path)
        # default_storage.save(photo_thumbnail_path, photo)

        # 群组照片缩略图生成
        # 双列: 540, 40-50K
        photo_w, photo_h, photo_thumbnail_w, photo_thumbnail_h = make_thumbnail(
            os.path.join(settings.MEDIA_ROOT, photo_path).replace('\\', '/'),
            os.path.join(settings.MEDIA_ROOT, photo_thumbnail_path).replace('\\', '/'),
            settings.THUMBNAIL_MAX_WIDTH
        )
        # 单列: 1080, xx-100K
        photo_w, photo_h, photo_thumbnail2_w, photo_thumbnail2_h = make_thumbnail(
            os.path.join(settings.MEDIA_ROOT, photo_path).replace('\\', '/'),
            os.path.join(settings.MEDIA_ROOT, photo_thumbnail2_path).replace('\\', '/'),
            settings.THUMBNAIL_MAX_WIDTH2
        )

        # 群组照片记录创建
        group_photo = GroupPhotoInfo.objects.create(
            group_id=group_id,
            user_id=user_id,
            nickname=nickname or user.final_nickname,
            avatar=user.avatar,
            photo_path=photo_path,
            photo_w=photo_w,
            photo_h=photo_h,
            photo_thumbnail_path=photo_thumbnail_path,
            photo_thumbnail_w=photo_thumbnail_w,
            photo_thumbnail_h=photo_thumbnail_h,
            photo_thumbnail2_path=photo_thumbnail2_path,
            photo_thumbnail2_w=photo_thumbnail2_w,
            photo_thumbnail2_h=photo_thumbnail2_h,
        )

        # 设置群组最后一张照片PK
        r.set(GROUP_LAST_PHOTO_PK % group_id, group_photo.pk)

    # 获取从 current_id 到 now 的群组照片列表
    group_photos = GroupPhotoInfo.objects.filter(
        group_id=group_id,
        status=True,
        pk__gt=max(current_id, group_user.current_id),
    ).order_by(
        '-pk'
    )
    latest_photo = group_photos.first()

    return JsonResponse({
        'status': 200,
        'message': u'飞图上传成功',
        'data': {
            'current_id': latest_photo and latest_photo.pk or current_id,
            'photos': [photo.photo_info(user_id) for photo in group_photos],
        }
    })


def comment_submit_api(request):
    """
    飞图评论提交／飞图评论列表
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')
    comment = request.POST.get('comment', '')

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    # 群组照片校验
    try:
        group_photo = GroupPhotoInfo.objects.get(pk=photo_id)
    except GroupPhotoInfo.DoesNotExist:
        return response(GroupPhotoStatusCode.GROUP_PHOTO_NOT_FOUND)

    if comment:
        # 群组照片评论记录创建
        PhotoCommentInfo.objects.create(
            photo_id=photo_id,
            user_id=user_id,
            nickname=group_user.nickname,
            avatar=group_user.avatar,
            comment=comment,
        )

        # 群组照片评论数更新
        group_photo.comment_num += 1
        group_photo.save()

        # 判断群组照片发布者是否已经被管理员移除／主动退出，如若移除／退出，则不给发布者提醒
        if r.sismember(GROUP_USERS_PASSED_SET % group_photo.group_id, group_photo.user_id):
            UserMessageInfo.objects.create(
                from_uid=user_id,
                from_nickname=group_user.nickname,
                from_avatar=group_user.avatar,
                to_uid=group_photo.user_id,
                group_id=group_photo.group_id,
                photo_id=group_photo.pk,
                msg_type=UserMessageInfo.COMMENT,
                msg_title=u'评论',
                msg_content=comment,
            )

    # 群组照片评论列表
    photo_comments = PhotoCommentInfo.objects.filter(
        photo_id=photo_id,
    )

    return JsonResponse({
        'status': 200,
        'message': u'评论成功',
        'data': {
            'comments': [comment.comment_info for comment in photo_comments],
        }
    })


def thumbup_submit_api(request):
    """
    飞图点赞提交
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    # 群组照片校验
    try:
        group_photo = GroupPhotoInfo.objects.get(pk=photo_id)
    except GroupPhotoInfo.DoesNotExist:
        return response(GroupPhotoStatusCode.GROUP_PHOTO_NOT_FOUND)

    # user_id 是否点赞 photo_id
    if PhotoThumbUpInfo.objects.filter(photo_id=photo_id, user_id=user_id, thumbup=True).exists():
        return response(GroupPhotoStatusCode.DUPLICATE_THUMB_UP)

    # 群组照片点赞记录创建／更新
    photo_thumbup, created = PhotoThumbUpInfo.objects.get_or_create(
        photo_id=photo_id,
        user_id=user_id,
    )
    photo_thumbup.nickname = group_user.nickname
    photo_thumbup.avatar = group_user.avatar
    photo_thumbup.thumbup = True
    photo_thumbup.save()

    # Redis 群组照片点赞数据缓存
    set_group_photo_thumbup_flag(photo_id, user_id)

    # 群组照片点赞数更新
    group_photo.thumbup_num += 1
    group_photo.save()

    # 判断群组照片发布者是否已经被管理员移除／主动退出，如若移除／退出，则不给发布者提醒
    if r.sismember(GROUP_USERS_PASSED_SET % group_photo.group_id, group_photo.user_id):
        UserMessageInfo.objects.create(
            from_uid=user_id,
            from_nickname=group_user.nickname,
            from_avatar=group_user.avatar,
            to_uid=group_photo.user_id,
            group_id=group_photo.group_id,
            photo_id=group_photo.pk,
            msg_type=UserMessageInfo.THUMBUP,
            msg_title=u'点赞',
            msg_content=u'点赞',
        )

    # 群组照片点赞列表
    photo_thumbups = PhotoThumbUpInfo.objects.filter(
        photo_id=photo_id,
        thumbup=True,
    )

    return JsonResponse({
        'status': 200,
        'message': u'点赞提交成功',
        'data': {
            'thumbup': True,
            'thumbups': [thumbup.thumbup_info for thumbup in photo_thumbups],
        }
    })


def thumbup_list_api(request):
    """
    飞图点赞列表
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')

    # user_id 是否点赞 photo_id
    thumbup = PhotoThumbUpInfo.objects.filter(photo_id=photo_id, user_id=user_id, thumbup=True).exists()

    # 群组照片点赞列表
    photo_thumbups = PhotoThumbUpInfo.objects.filter(
        photo_id=photo_id,
        thumbup=True,
    )

    return JsonResponse({
        'status': 200,
        'message': u'获取点赞列表成功',
        'data': {
            'thumbup': thumbup,
            'thumbups': [thumbup.thumbup_info for thumbup in photo_thumbups],
        }
    })


def thumbup_cancel_api(request):
    """
    飞图点赞取消
    :param request:
    :return:
    """
    group_id = request.POST.get('group_id', '')
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')

    # 群组用户校验
    try:
        group_user = GroupUserInfo.objects.get(group_id=group_id, user_id=user_id, user_status=GroupUserInfo.PASSED)
    except GroupUserInfo.DoesNotExist:
        return response(GroupUserStatusCode.GROUP_USER_NOT_FOUND)

    # 群组照片校验
    try:
        group_photo = GroupPhotoInfo.objects.get(pk=photo_id)
    except GroupPhotoInfo.DoesNotExist:
        return response(GroupPhotoStatusCode.GROUP_PHOTO_NOT_FOUND)

    # user_id 是否点赞 photo_id
    if not PhotoThumbUpInfo.objects.filter(photo_id=photo_id, user_id=user_id, thumbup=True).exists():
        return response(GroupPhotoStatusCode.THUMB_UP_NOT_FOUND)

    # 群组照片点赞取消
    photo_thumbup, created = PhotoThumbUpInfo.objects.get_or_create(
        photo_id=photo_id,
        user_id=user_id,
    )
    photo_thumbup.thumbup = False
    photo_thumbup.save()

    # Redis 群组照片点赞数据移除
    del_group_photo_thumbup_flag(photo_id, user_id)

    # 群组照片点赞数更新
    group_photo.thumbup_num -= 1
    group_photo.save()

    # 判断群组照片发布者是否已经被管理员移除／主动退出，如若移除／退出，则不给发布者提醒
    if r.sismember(GROUP_USERS_PASSED_SET % group_photo.group_id, group_photo.user_id):
        UserMessageInfo.objects.create(
            from_uid=user_id,
            from_nickname=group_user.nickname,
            from_avatar=group_user.avatar,
            to_uid=group_photo.user_id,
            group_id=group_photo.group_id,
            photo_id=group_photo.pk,
            msg_type=UserMessageInfo.THUMBUP,
            msg_title=u'取消点赞',
            msg_content=u'取消点赞',
        )

    # 群组照片点赞列表
    photo_thumbups = PhotoThumbUpInfo.objects.filter(
        photo_id=photo_id,
        thumbup=True,
    )

    return JsonResponse({
        'status': 200,
        'message': u'点赞取消成功',
        'data': {
            'thumbup': False,
            'thumbups': [thumbup.thumbup_info for thumbup in photo_thumbups],
        }
    })


def pai2_home_api(request):
    """
    首页信息
    :param request:
    :return:
    """
    user_id = request.POST.get('user_id', '')
    page = int(request.POST.get('page', 1))
    num = int(request.POST.get('num', settings.PAI2_HOME_PER_PAGE))

    # 执行原生 SQL 语句，获取首页照片列表
    cursor = connection.cursor()
    cursor.execute(PAI2_HOME_API.format(
        user_id=user_id,
        offset=0,
        rows=settings.PAI2_HOME_MAX_ROWS,
    ))
    rows = cursor.fetchall()

    # 首页照片分页
    rows, left = pagination(rows, page, num)

    # 首页照片信息
    rows = [{
        'group_id': row[0],
        'group_name': row[1],
        'group_default_avatar': row[2],
        'group_avatar': row[3],
        'group_from': row[4],
        'photo_id': row[5],
        'photo_url': img_url(row[6]),
        'photo_w': row[7],
        'photo_h': row[8],
        'photo_thumbnail_url': img_url(row[9]),
        'photo_thumbnail_w': row[10],
        'photo_thumbnail_h': row[11],
        'photo_thumbnail2_url': img_url(row[12]),
        'photo_thumbnail2_w': row[13],
        'photo_thumbnail2_h': row[14],
        'user_id': row[15],
        'nickname': row[16],
        'avatar': row[17],
        'comment_num': row[18],
        'thumbup_num': row[19],
        'photo_from': row[20],
        'created_at': row[21],
    } for row in rows]

    [row.update({
        'thumbup': get_group_photo_thumbup_flag(row['photo_id'], user_id),
        'porder': get_lensman_order_record(row['photo_id'], user_id) if row['photo_from'] == GroupPhotoInfo.SESSION_GROUP else {}
    }) for row in rows]

    return JsonResponse({
        'status': 200,
        'message': u'获取首页列表成功',
        'data': {
            'photos': rows,
            'left': left,
        }
    })


def lensman_photo_price(request):
    """
    摄影师照片价格获取
    :param request:
    :return:
    """
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')
    photo_type = request.POST.get('photo_type', 'nomark')  # nomark for 去除水印, origin for 获取高清图

    # 处理价格逻辑
    lensman_photo_price_key = LENSMAN_PHOTO_PRICE % (user_id, photo_id, photo_type)
    lensman_photo_haggle_times_key = LENSMAN_PHOTO_HAGGLE_TIMES % (user_id, photo_id, photo_type)
    # Redis 获取存储的价格
    price = int(r.get(lensman_photo_price_key) or 0)
    if price:
        haggle_times = int(r.get(lensman_photo_haggle_times_key) or 0)
        # 砍价逻辑
        if haggle_times < settings.LENSMAN_PHOTO_HAGGLE_MAX_TIMES:
            price -= random.choice([50, 100])
            r.incr(lensman_photo_haggle_times_key)
    else:
        # 获取摄影师定价
        # TODO, 此处需要完整的摄影师定价
        price = 999 if photo_type == 'origin' else 666

    r.set(lensman_photo_price_key, price)

    return JsonResponse({
        'status': 200,
        'message': u'获取价格成功',
        'data': {
            'price': price
        }
    })


def lensman_photo_bought(request):
    """
    摄影师照片已购买
    :param request:
    :return:
    """
    user_id = request.POST.get('user_id', '')
    photo_id = request.POST.get('photo_id', '')

    return JsonResponse({
        'status': 200,
        'message': u'获取购买数据成功',
        'data': {
            'porder': get_lensman_order_record(photo_id, user_id)
        }
    })


def group_detail(request, group_id):
    return render(request, 'page/download.html', {})


class GroupInfoViewSet(viewsets.ModelViewSet):
    queryset = GroupInfo.objects.all().order_by('-pk')
    serializer_class = GroupInfoSerializer


class GroupUserInfoViewSet(viewsets.ModelViewSet):
    queryset = GroupUserInfo.objects.all().order_by('-pk')
    serializer_class = GroupUserInfoSerializer


class GroupPhotoInfoViewSet(viewsets.ModelViewSet):
    queryset = GroupPhotoInfo.objects.all().order_by('-pk')
    serializer_class = GroupPhotoInfoSerializer


# Only Once Function
def refresh_thumbnail():
    photos = GroupPhotoInfo.objects.filter(status=True)

    for photo in photos:
        try:
            photo_path = photo.photo_path
            photo_thumbnail_path = photo_path.replace('.', '_thumbnail.')
            photo_thumbnail2_path = photo_path.replace('.', '_thumbnail2.')

            # 群组照片缩略图生成
            # 双列: 540, 40-50K
            photo_w, photo_h, photo_thumbnail_w, photo_thumbnail_h = make_thumbnail(
                os.path.join(settings.MEDIA_ROOT, photo_path).replace('\\', '/'),
                os.path.join(settings.MEDIA_ROOT, photo_thumbnail_path).replace('\\', '/'),
                settings.THUMBNAIL_MAX_WIDTH
            )
            # 单列: 1080, xx-100K
            photo_w, photo_h, photo_thumbnail2_w, photo_thumbnail2_h = make_thumbnail(
                os.path.join(settings.MEDIA_ROOT, photo_path).replace('\\', '/'),
                os.path.join(settings.MEDIA_ROOT, photo_thumbnail2_path).replace('\\', '/'),
                settings.THUMBNAIL_MAX_WIDTH2
            )

            photo.photo_w = photo_w
            photo.photo_h = photo_h
            photo.photo_thumbnail_path = photo_thumbnail_path
            photo.photo_thumbnail_w = photo_thumbnail_w
            photo.photo_thumbnail_h = photo_thumbnail_h
            photo.photo_thumbnail2_path = photo_thumbnail2_path
            photo.photo_thumbnail2_w = photo_thumbnail2_w
            photo.photo_thumbnail2_h = photo_thumbnail2_h

            photo.save()
        except Exception as e:
            pass

    return 'Refresh Thumbnail OK'