from django.db import models

from meanings.models import LexicalUnit, Synset

class UnifiedLexicalUnitCluster(models.Model):
    lexical_units = models.ManyToManyField(LexicalUnit, related_name='UnifiedLexicalUnitCluster')

    def __str__(self):
        return '%s: %s' % (self.opinion, ' + '.join([str(arg) for arg in self.sorted_arguments()]))

class UnifiedFrameStatus(models.Model):
    status = models.CharField(max_length=20)

    def __str__(self):
        return self.status

class UnifiedFrame(models.Model):
    unified_lexical_unit_cluster = models.ForeignKey(UnifiedLexicalUnitCluster, on_delete=models.PROTECT)
    status = models.ForeignKey(UnifiedFrameStatus, on_delete=models.PROTECT)
    arguments_count = models.PositiveIntegerField(null=False, default=0)

    def sorted_arguments(self):  # TODO: zaimplementowac wlasciwe sortowanie
        return Argument.objects.filter(frame=self)

    def __str__(self):
        return '%s: %s' % (self.opinion, ' + '.join([str(arg) for arg in self.sorted_arguments()]))





class Argument(models.Model):
    role = models.ForeignKey('ArgumentRole', on_delete=models.PROTECT)
    predefined = models.ManyToManyField('PredefinedSelectionalPreference')
    synsets = models.ManyToManyField(Synset)
    relations = models.ManyToManyField('RelationalSelectionalPreference')
    frame = models.ForeignKey(Frame, related_name='arguments', on_delete=models.PROTECT)
    preferences_count = models.PositiveIntegerField(null=False, default=0)

    def __str__(self):
        return str(self.role)


class ArgumentRole(models.Model):
    role = models.ForeignKey('SemanticRole', on_delete=models.PROTECT)
    attribute = models.ForeignKey('RoleAttribute', null=True, on_delete=models.PROTECT)

    def __str__(self):
        if self.attribute is None:
            return str(self.role)
        else:
            return '{}, {}'.format(str(self.role), str(self.attribute))


class SemanticRole(models.Model):
    role = models.CharField(max_length=20)
    color = models.CharField(max_length=11, null=True)
    priority = models.PositiveIntegerField()

    class Meta:
        ordering = ['priority']

    def __str__(self):
        return self.role


class RoleAttribute(models.Model):
    attribute = models.CharField(max_length=20)
    gradient = models.CharField(max_length=10, null=True)
    priority = models.PositiveIntegerField()

    class Meta:
        ordering = ['priority']

    def __str__(self):
        return self.attribute


class PredefinedSelectionalPreference(models.Model):
    key = models.CharField(max_length=20, unique=True)
    # name = TODO: wymaga lokalizacji

    def __str__(self):
        return self.key


class RelationalSelectionalPreference(models.Model):
    relation = models.ForeignKey('SelectionalPreferenceRelation', on_delete=models.PROTECT)
    to = models.ForeignKey('Argument', on_delete=models.PROTECT)

    def __str__(self):
        return '%s -> %s' % (self.relation, self.to)


class SelectionalPreferenceRelation(models.Model):
    key = models.CharField(max_length=40, unique=True)
    # name = TODO: wymaga lokalizacji
    plwn_id = models.IntegerField(null=True)
    
    class Meta:
        ordering = ['key']

    def __str__(self):
        return self.key