from datetime import timedelta

from django.contrib.auth import get_user_model
from django.utils import timezone

from misago.core.utils import slugify

from .checksums import update_post_checksum
from .models import Poll, Post, Thread


def post_thread(category, title='Test thread', poster='Tester',
                is_global=False, is_pinned=False, is_unapproved=False,
                is_hidden=False, is_closed=False, started_on=None):
    started_on = started_on or timezone.now()

    kwargs = {
        'category': category,
        'title': title,
        'slug': slugify(title),
        'started_on': started_on,
        'last_post_on': started_on,
        'is_unapproved': is_unapproved,
        'is_hidden': is_hidden,
        'is_closed': is_closed
    }

    if is_global:
        kwargs['weight'] = 2
    elif is_pinned:
        kwargs['weight'] = 1

    try:
        kwargs.update({
            'starter': poster,
            'starter_name': poster.username,
            'starter_slug': poster.slug,
            'last_poster': poster,
            'last_poster_name': poster.username,
            'last_poster_slug': poster.slug,
            })
    except AttributeError:
        kwargs.update({
            'starter_name': poster,
            'starter_slug': slugify(poster),
            'last_poster_name': poster,
            'last_poster_slug': slugify(poster),
        })

    thread = Thread.objects.create(**kwargs)
    reply_thread(
        thread,
        poster=poster,
        posted_on=started_on,
        is_hidden=is_hidden,
        is_unapproved=is_unapproved,
    )

    return thread


def reply_thread(thread, poster="Tester", message="I am test message",
                 is_unapproved=False, is_hidden=False, is_event=False,
                 has_reports=False, has_open_reports=False, posted_on=None, poster_ip='127.0.0.1'):
    posted_on = posted_on or thread.last_post_on + timedelta(minutes=5)

    kwargs = {
        'category': thread.category,
        'thread': thread,
        'original': message,
        'parsed': message,
        'checksum': 'nope',
        'poster_ip': poster_ip,
        'posted_on': posted_on,
        'updated_on': posted_on,
        'is_event': is_event,
        'is_unapproved': is_unapproved,
        'is_hidden': is_hidden,
        'has_reports': has_reports,
        'has_open_reports': has_open_reports,
    }

    try:
        kwargs.update({'poster': poster, 'poster_name': poster.username})
    except AttributeError:
        kwargs.update({'poster_name': poster})

    post = Post.objects.create(**kwargs)

    update_post_checksum(post)
    post.save()

    thread.synchronize()
    thread.save()
    thread.category.synchronize()
    thread.category.save()

    return post


def post_poll(thread, poster):
    poll = Poll.objects.create(
        category=thread.category,
        thread=thread,
        poster=poster,
        poster_name=poster.username,
        poster_slug=poster.slug,
        poster_ip='127.0.0.1',
        question="Lorem ipsum dolor met?",
        choices=[
            {
                'hash': 'aaaaaaaaaaaa',
                'label': 'Alpha',
                'votes': 1
            },
            {
                'hash': 'bbbbbbbbbbbb',
                'label': 'Beta',
                'votes': 0
            },
            {
                'hash': 'gggggggggggg',
                'label': 'Gamma',
                'votes': 2
            },
            {
                'hash': 'dddddddddddd',
                'label': 'Delta',
                'votes': 1
            }
        ],
        allowed_choices=2,
        votes=4
    )

    # one user voted for Alpha choice
    User = get_user_model()
    try:
        user = User.objects.get(slug='bob')
    except User.DoesNotExist:
        user = User.objects.create_user('bob', 'bob@test.com', 'Pass.123')

    poll.pollvote_set.create(
        category=thread.category,
        thread=thread,
        voter=user,
        voter_name=user.username,
        voter_slug=user.slug,
        voter_ip='127.0.0.1',
        choice_hash='aaaaaaaaaaaa'
    )

    # test user voted on third and last choices
    poll.pollvote_set.create(
        category=thread.category,
        thread=thread,
        voter=poster,
        voter_name=poster.username,
        voter_slug=poster.slug,
        voter_ip='127.0.0.1',
        choice_hash='gggggggggggg'
    )
    poll.pollvote_set.create(
        category=thread.category,
        thread=thread,
        voter=poster,
        voter_name=poster.username,
        voter_slug=poster.slug,
        voter_ip='127.0.0.1',
        choice_hash='dddddddddddd'
    )

    # somebody else voted on third option before being deleted
    poll.pollvote_set.create(
        category=thread.category,
        thread=thread,
        voter_name='deleted',
        voter_slug='deleted',
        voter_ip='127.0.0.1',
        choice_hash='gggggggggggg'
    )

    return poll


def like_post(post, user=None, username=None):
    if not post.last_likes:
        post.last_likes = []

    if user:
        like = post.postlike_set.create(
            category=post.category,
            thread=post.thread,
            user=user,
            user_name=user.username,
            user_slug=user.slug,
            user_ip='127.0.0.1'
        )

        post.last_likes = [
            {
                'id': user.id,
                'username': user.username
            }
        ] + post.last_likes
    else:
        like = post.postlike_set.create(
            category=post.category,
            thread=post.thread,
            user_name=username,
            user_slug=slugify(username),
            user_ip='127.0.0.1'
        )

        post.last_likes = [
            {
                'id': None,
                'username': username
            }
        ] + post.last_likes

    post.likes += 1
    post.save()

    return like