import json
import logging
import os
import pytz
import yaml
from datetime import datetime
from os.path import basename

from django.conf import settings
from django.contrib.auth.models import User
from django.db import models
from django.db.models import Q
from django.db.models.signals import pre_delete
from django.dispatch import receiver

logger = logging.getLogger(__name__)


class MinecraftManagerUser(User):

    class Meta:
        proxy = True
        permissions = (
            ('bots', 'Can use the bot control page'),
            ('chat', 'Can use chat page'),
        )


class UserSettings(models.Model):
    RESULT_OPTIONS = (
        (10, '10'),
        (25, '25'),
        (50, '50'),
        (100, '100'),
        (-1, 'All')
    )
    THEME_OPTIONS = (
        ('DE', 'Default'),
        ('DA', 'Dark'),
        ('SO', 'Solar'),
        ('SL', 'Slate')
    )
    tzs = []
    for tz in pytz.common_timezones:
        tzs.append((tz, tz))
    TIMEZONES = tuple(tzs)
    auth_user = models.OneToOneField(User, on_delete=models.CASCADE, null=True, blank=True)
    default_results = models.SmallIntegerField("Default Results", default=10, choices=RESULT_OPTIONS)
    default_theme = models.CharField("Theme", max_length=2, default='DE', choices=THEME_OPTIONS)
    default_timezone = models.CharField("Timezone", max_length=50, default='UTC', choices=TIMEZONES)
    search_player_ip = models.BooleanField("Include IP in Player search", default=False)
    show_timestamp_chat = models.BooleanField("Show Timestamp By Chat", default=False)
    last_ip = models.CharField(max_length=30, default="127.0.0.1", editable=False)

    class Meta:
        verbose_name = "User Settings"
        verbose_name_plural = "User Settings"

    def __str__(self):
        return self.auth_user.username

    def __repr__(self):
        return self.auth_user.username


class Application(models.Model):
    username = models.CharField("Minecraft Username", max_length=20, unique=True)
    age = models.PositiveSmallIntegerField()
    player_type = models.TextField("What type of player are you?", max_length=300)
    ever_banned = models.BooleanField("Have you ever been banned?", default=False)
    ever_banned_explanation = models.TextField("If you were previously banned, will you share why?", max_length=300, blank=True, null=True)
    reference = models.CharField("How did you find out about our server?", max_length=50, blank=True, null=True)
    read_rules = models.CharField("Have you read the rules?", max_length=10)
    accepted = models.NullBooleanField()
    date = models.DateTimeField(auto_now_add=True, blank=True, null=True)
    objects = models.Manager()

    @property
    def status(self):
        if self.accepted is not None:
            if self.accepted is True:
                return "Accepted"
            elif self.accepted is False:
                return "Denied"
            else:
                return "Unknown"
        else:
            return "Unanswered"

    @property
    def date_display(self):
        return str(self.date).split(".")[0]

    def __str__(self):
        return self.username

    def __repr__(self):
        return self.username


class Player(models.Model):
    auth_user = models.OneToOneField(User, on_delete=models.SET_NULL, null=True, blank=True)
    uuid = models.CharField(max_length=36, unique=True)
    username = models.CharField(max_length=20)
    application = models.ForeignKey(Application, on_delete=models.SET_NULL, null=True, blank=True)
    first_seen = models.DateField(null=True, blank=True)
    last_seen = models.DateField(null=True, blank=True)


    @property
    def is_banned(self):
        ban_file = os.path.join(settings.MINECRAFT_BASE_DIR, 'banned-players.json')
        with open(ban_file, encoding='utf-8') as f:
            bans = json.load(f)
        if bans:
            for ban in bans:
                if self.uuid == ban['uuid']:
                    return True
            return False
        else:
            return False

    @property
    def donor_status(self):

        def format_time(timestamp):
            return datetime.utcfromtimestamp(timestamp).strftime('%m/%d/%Y')

        try:
            from django_luckperms.models import LuckPermsPlayerPermissions as lppp
            donator = lppp.objects.filter(permission='group.donator', uuid=self.uuid)
            if donator.exists():
                expiry = donator.first().expiry
                if expiry > 0:
                    return "Until {}".format(format_time(expiry))
                else:
                    return "Permanent"
            else:
                return "None"
        except:
            pass
        try:
            pex_file = os.path.join(getattr(settings, 'MINECRAFT_BASE_DIR', ''), 'plugins/PermissionsEx/permissions.yml')
            with open(pex_file) as f:
                yml = yaml.load(f)
            for user in yml['users']:
                if user == self.uuid:
                    if 'donator' in yml['users'][user]['group']:
                        u = yml['users'][user]
                        if 'group-donator-until' in u['options']:
                            unix_time = float(u['options']['group-donator-until'])
                            return 'Until {0}'.format(format_time(unix_time))
                        else:
                            return 'Permanent'
                    else:
                        return 'None'
        except:
            pass
        return "N/A"

    @property
    def ips(self):
        ips = []
        if not getattr(self.auth_user, 'is_active', False):
            query = IP.objects.filter(player=self)
            for q in query:
                ips.append(q.ip)
        return " ".join(ips)

    def __str__(self):
        return "{} ({})".format(self.username, self.uuid)


class Ticket(models.Model):
    PRIORITY = (
        ('L', 'Low'),
        ('M', 'Medium'),
        ('H', 'High')
    )
    WORLDS = (
        ('O', 'Overworld'),
        ('N', 'Nether'),
        ('E', 'The End')
    )
    player = models.ForeignKey(Player, related_name="ticket_player", on_delete=models.CASCADE, blank=True, null=True)
    message = models.CharField(max_length=500)
    priority = models.CharField(max_length=1, choices=PRIORITY, blank=True, default='L')
    staff = models.ForeignKey(User, related_name="ticket_staff", on_delete=models.CASCADE, null=True, blank=True)
    resolved = models.BooleanField(default=False)
    world = models.CharField(max_length=1, choices=WORLDS, blank=True, null=True)
    x = models.CharField(max_length=20, blank=True, null=True)
    y = models.CharField(max_length=20, blank=True, null=True)
    z = models.CharField(max_length=20, blank=True, null=True)
    date = models.DateTimeField(auto_now_add=True, null=True, blank=True)
    objects = models.Manager()

    @property
    def location(self):
        return "{0}, {1}, {2} in {3}".format(self.x, self.y, self.z, self.world_label)

    @property
    def world_label(self):
        for W in self.WORLDS:
            if W[0] == self.world:
                return W[1]
        return ""

    @property
    def resolved_label(self):
        if self.resolved:
            return "Resolved"
        else:
            return "Unresolved"

    @property
    def snippet(self):
        if len(self.message) > 50:
            return self.message[:50] + "..."
        else:
            return self.message

    @property
    def issuer(self):
        if self.player:
            pl = Player.objects.get(id=self.player_id)
            return pl.username
        else:
            return "Unknown"

    @property
    def claimed_by(self):
        if self.staff:
            pl = User.objects.get(id=self.staff_id)
            return pl.username
        else:
            return "Unclaimed"

    @property
    def is_claimed(self):
        if self.staff:
            return True
        else:
            return False

    @property
    def priority_display(self):
        for P in self.PRIORITY:
            if P[0] == self.priority:
                return P[1]
        return "Unknown"

    @staticmethod
    def priority_code_to_display(piority_code):
        for P in Ticket.PRIORITY:
            if P[0] == piority_code:
                return P[1]
        return "Unknown"

    @property
    def date_display(self):
        return str(self.date).split(".")[0]

    @property
    def notes(self):
        return TicketNote.objects.filter(ticket=self)

    def __str__(self):
        return "{}: {}".format(self.issuer, self.snippet)


class TicketNote(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    ticket = models.ForeignKey(Ticket, on_delete=models.CASCADE)
    message = models.TextField(max_length=1000)
    last_update = models.DateTimeField(auto_now_add=True, blank=True, null=True)
    date = models.DateTimeField(auto_now_add=True, blank=True, null=True)

    @property
    def attachments(self):
        return Attachment.objects.filter(ref_model=RefModels.TICKET_NOTE[0], ref_id=self.id)

    class Meta:
        verbose_name = "Ticket Note"
        verbose_name_plural = "Ticket Notes"

    def __str__(self):
        return "Ticket: {0}".format(self.ticket.snippet)


class Note(models.Model):
    IMPORTANCE = (
        ('L', 'Low'),
        ('M', 'Medium'),
        ('H', 'High')
    )
    player = models.ForeignKey(Player, related_name="note_player", on_delete=models.CASCADE)
    message = models.CharField(max_length=200)
    importance = models.CharField(max_length=1, choices=IMPORTANCE)
    staff = models.ForeignKey(User, related_name="note_staff", on_delete=models.CASCADE, null=True, blank=True, limit_choices_to=Q(is_active=True))
    date = models.DateTimeField(auto_now_add=True, blank=True, null=True)

    @property
    def snippet(self):
        if len(self.message) > 50:
            return self.message[:50] + "..."
        else:
            return self.message

    @property
    def importance_display(self):
        for S in self.IMPORTANCE:
            if S[0] == self.importance:
                return S[1]
        return "Unknown"

    @staticmethod
    def importance_code_to_display(importance_code):
        for S in Note.IMPORTANCE:
            if S[0] == importance_code:
                return S[1]
        return "Unknown"

    @property
    def issuer(self):
        if self.staff:
            pl = User.objects.get(id=self.staff_id)
            return pl.username
        else:
            return "System"

    @property
    def issuee(self):
        if self.player:
            pl = Player.objects.get(id=self.player_id)
            return pl.username
        else:
            return "Unknown"

    @property
    def date_display(self):
        return str(self.date).split(".")[0]

    @property
    def attachments(self):
        return Attachment.objects.filter(ref_model=RefModels.NOTE[0], ref_id=self.id)

    def __str__(self):
        return "{}: {}".format(self.issuee, self.snippet)


class RefModels:
    TICKET_NOTE = 'T', 'Ticket Note'
    NOTE = 'N', 'Note'
    choices = TICKET_NOTE, NOTE

    @staticmethod
    def label(ref: str):
        for c in RefModels.choices:
            if c[0] == ref:
                return c[1]
        return "None"


def _attachment_upload_to(instance, filename):
    return f"attachments/{instance.ref_name.lower().replace(' ', '_')}s/{instance.ref_id}/{filename}"


class Attachment(models.Model):
    ref_model = models.CharField(max_length=1, choices=RefModels.choices)
    ref_id = models.IntegerField()
    file = models.FileField(upload_to=_attachment_upload_to)
    created = models.DateTimeField(auto_now_add=True)

    @property
    def ref_name(self):
        return RefModels.label(self.ref_model)

    @property
    def file_name(self):
        return basename(self.file.name)

    def __str__(self):
        return self.file.name


@receiver(pre_delete, sender=Attachment, dispatch_uid="delete_attachments")
def attachment_delete(sender, instance, **kwargs):
    instance.file.delete(False)


class IPManager(models.Manager):
    def get_queryset(self):
        users = User.objects.filter(is_active=True)
        filtered = []
        for user in users:
            if getattr(user, 'player', False):
                ips = IP.objects.filter(player=user.player)
                for ip in ips:
                    filtered.append(ip.ip)
        return super(IPManager, self).get_queryset().exclude(ip__in=filtered)


class IP(models.Model):
    player = models.ForeignKey(Player, on_delete=models.CASCADE)
    ip = models.CharField(max_length=30)
    last_used = models.DateField(null=True, blank=True)
    objects = models.Manager()
    api = IPManager()

    class Meta:
        verbose_name = "IP"
        verbose_name_plural = "IPs"

    @property
    def last_used_formatted(self):
        if self.last_used:
            return self.last_used
        else:
            return "N/A"

    @property
    def associated(self):
        ips = IP.api.filter(ip=self.ip)
        players = []
        for ip in ips:
            if self.player != ip.player:
                players.append(ip.player)
        if players:
            return players
        else:
            return None

    def __str__(self):
        player = Player.objects.get(id=self.player_id)
        return "{}: {}".format(player.username, self.ip)


class Alert(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    message = models.TextField(max_length=1000)
    seen = models.BooleanField(default=False)
    date = models.DateTimeField(auto_now_add=True, blank=True, null=True)

    @property
    def snippet(self):
        if len(self.message) > 50:
            return self.message[:50] + "..."
        else:
            return self.message

    def __str__(self):
        return "Alert for {}".format(self.user.username)