from django.db import models


class Region(models.Model):
    """Mirror model for sports.Region from Internal DB"""
    
    TYPE_CHOICES = [
        ('WORLDWIDE', 'Worldwide'),
        ('CONTINENTAL', 'Continental'),
        ('SUB_CONTINENTAL', 'Sub-Continental'),
        ('COUNTRY', 'Country'),
        ('CITY', 'City'),
    ]
    
    STATUS_CHOICES = [
        ('ACTIVE', 'Active'),
        ('INACTIVE', 'Inactive'),
        ('DELETED', 'Deleted'),
    ]
    
    name = models.CharField(max_length=200)
    type = models.CharField(max_length=20, choices=TYPE_CHOICES)
    parent = models.ForeignKey('self', on_delete=models.DO_NOTHING, null=True, blank=True, related_name='subregions', db_column='parent_id')
    iso_code = models.CharField(max_length=10, blank=True)
    description = models.TextField(blank=True)
    flag = models.CharField(max_length=100, null=True, blank=True)  # ImageField como CharField
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='ACTIVE')
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()
    
    class Meta:
        managed = False
        db_table = 'sports_region'
        ordering = ['type', 'name']
    
    def __str__(self):
        if self.parent:
            return f"{self.name} ({self.parent.name})"
        return self.name


class Division(models.Model):
    """Mirror model for sports.Division from Internal DB"""
    
    TYPE_CHOICES = [
        ('professional', 'Professional'),
        ('subdivision', 'Subdivision'),
        ('other', 'Other'),
    ]

    GENDER_CHOICES = [
        ('male', 'Male'),
        ('female', 'Female'),
        ('mixed', 'Mixed'),
    ]

    name = models.CharField(max_length=100, unique=True)
    type = models.CharField(max_length=20, choices=TYPE_CHOICES, default='subdivision')
    gender = models.CharField(max_length=10, choices=GENDER_CHOICES, default='male')
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return f"{self.name} ({self.get_gender_display()}, {self.get_type_display()})"

    class Meta:
        managed = False
        db_table = 'sports_division'
        ordering = ['name']


class Team(models.Model):
    """Mirror model for sports.Team from Internal DB"""
    
    name = models.CharField(max_length=100)
    code = models.CharField(max_length=10, unique=True)
    logo = models.CharField(max_length=100, null=True, blank=True)  # ImageField como CharField
    country = models.ForeignKey(Region, on_delete=models.DO_NOTHING, null=True, blank=True, related_name='teams', db_column='country_id')
    city = models.ForeignKey(Region, on_delete=models.DO_NOTHING, null=True, blank=True, related_name='city_teams', db_column='city_id')
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        country_code = self.country.iso_code if self.country else "??"
        return f"{self.name} ({country_code})"

    class Meta:
        managed = False
        db_table = 'sports_team'
        ordering = ['name']


class TeamDivision(models.Model):
    """Mirror model for sports.TeamDivision from Internal DB"""
    
    team = models.ForeignKey(Team, on_delete=models.DO_NOTHING, related_name='team_divisions', db_column='team_id')
    division = models.ForeignKey(Division, on_delete=models.DO_NOTHING, related_name='team_divisions', db_column='division_id')
    is_active = models.BooleanField(default=True)
    start_date = models.DateField(null=True, blank=True)
    end_date = models.DateField(null=True, blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        status = "✓ Active" if self.is_active else "✗ Inactive"
        return f"{self.team.name} - {self.division.name} [{status}]"

    class Meta:
        managed = False
        db_table = 'sports_teamdivision'
        ordering = ['team', '-is_active', 'division']


class Player(models.Model):
    """Mirror model for sports.Player from Internal DB"""
    
    PLAYER_STATUS = [
        ('active', 'Active'),
        ('injured', 'Injured'),
        ('suspended', 'Suspended'),
        ('inactive', 'Inactive'),
    ]

    name = models.CharField(max_length=100)
    birthdate = models.DateField(null=True, blank=True)
    nationality = models.ForeignKey(Region, on_delete=models.DO_NOTHING, null=True, blank=True, related_name='players', db_column='nationality_id')
    photo = models.CharField(max_length=100, null=True, blank=True)  # ImageField como CharField
    height = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
    weight = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
    preferred_foot = models.CharField(max_length=10, null=True, blank=True)
    status = models.CharField(max_length=20, choices=PLAYER_STATUS, default='active')
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return self.name

    class Meta:
        managed = False
        db_table = 'sports_player'
        ordering = ['name']


class PlayerRole(models.Model):
    """Mirror model for sports.PlayerRole from Internal DB"""
    
    ROLE_CATEGORY_CHOICES = [
        ('goalkeeper', 'Goalkeeper'),
        ('defender', 'Defender'),
        ('midfielder', 'Midfielder'),
        ('forward', 'Forward'),
    ]

    name = models.CharField(max_length=50, unique=True)
    short_name = models.CharField(max_length=10, unique=True)
    category = models.CharField(max_length=20, choices=ROLE_CATEGORY_CHOICES)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return f"{self.name} ({self.short_name})"

    class Meta:
        managed = False
        db_table = 'sports_playerrole'
        ordering = ['category', 'name']


class TeamDivisionPlayer(models.Model):
    """Mirror model for sports.TeamDivisionPlayer from Internal DB"""
    
    STATE_CHOICES = [
        ('active', 'Active'),
        ('loaned', 'Loaned'),
        ('transferred', 'Transferred'),
        ('released', 'Released'),
        ('retired', 'Retired'),
    ]

    team_division = models.ForeignKey(TeamDivision, on_delete=models.DO_NOTHING, related_name='team_division_players', db_column='team_division_id')
    player = models.ForeignKey(Player, on_delete=models.DO_NOTHING, related_name='team_assignments', db_column='player_id')
    primary_role = models.ForeignKey(PlayerRole, on_delete=models.DO_NOTHING, related_name='primary_assignments', null=True, blank=True, db_column='primary_role_id')
    jersey_number = models.PositiveIntegerField(null=True, blank=True)
    state = models.CharField(max_length=20, choices=STATE_CHOICES, default='active')
    start_date = models.DateField(null=True, blank=True)
    end_date = models.DateField(null=True, blank=True)
    market_value = models.DecimalField(max_digits=12, decimal_places=2, null=True, blank=True)
    notes = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        jersey = f"#{self.jersey_number}" if self.jersey_number else "No jersey"
        return f"{self.player.name} - {self.team_division.team.name} ({self.team_division.division.name}) {jersey}"

    class Meta:
        managed = False
        db_table = 'sports_teamdivisionplayer'
        ordering = ['team_division', 'jersey_number']


class Competition(models.Model):
    """Mirror model for sports.Competition from Internal DB"""
    
    TYPE_CHOICES = [
        ('league', 'League'),
        ('cup', 'Cup'),
        ('friendly', 'Friendly'),
        ('playoff', 'Playoff'),
    ]

    name = models.CharField(max_length=200)
    short_name = models.CharField(max_length=50, blank=True)
    logo = models.CharField(max_length=100, null=True, blank=True)  # ImageField como CharField
    type = models.CharField(max_length=20, choices=TYPE_CHOICES, default='league')
    region = models.ForeignKey(Region, on_delete=models.DO_NOTHING, null=True, blank=True, related_name='competitions', db_column='region_id')
    division = models.ForeignKey(Division, on_delete=models.DO_NOTHING, related_name='competitions', db_column='division_id')
    season_start = models.DateField(null=True, blank=True)
    season_end = models.DateField(null=True, blank=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        region_name = f" - {self.region.name}" if self.region else ""
        return f"{self.name}{region_name} ({self.division.name})"

    class Meta:
        managed = False
        db_table = 'sports_competition'
        ordering = ['-season_start', 'name']


class Match(models.Model):
    """Mirror model for sports.Match from Internal DB"""
    
    name = models.CharField(max_length=200, blank=True)
    home_team_division = models.ForeignKey(TeamDivision, on_delete=models.DO_NOTHING, related_name='home_matches', db_column='home_team_division_id')
    away_team_division = models.ForeignKey(TeamDivision, on_delete=models.DO_NOTHING, related_name='away_matches', db_column='away_team_division_id')
    competition = models.ForeignKey(Competition, on_delete=models.DO_NOTHING, null=True, blank=True, related_name='matches', db_column='competition_id')
    date = models.DateTimeField()
    location = models.CharField(max_length=200, blank=True)
    home_score = models.IntegerField(null=True, blank=True)
    away_score = models.IntegerField(null=True, blank=True)
    attendance = models.IntegerField(null=True, blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        score_info = ""
        if self.home_score is not None and self.away_score is not None:
            score_info = f" ({self.home_score}-{self.away_score})"
        return f"{self.home_team_division.team.name} vs {self.away_team_division.team.name}{score_info}"

    class Meta:
        managed = False
        db_table = 'sports_match'
        ordering = ['-date']


class MatchLineup(models.Model):
    """Mirror model for sports.MatchLineup from Internal DB"""
    
    match = models.ForeignKey(Match, on_delete=models.DO_NOTHING, related_name='lineups', db_column='match_id')
    team_division_player = models.ForeignKey(TeamDivisionPlayer, on_delete=models.DO_NOTHING, related_name='match_lineups', db_column='team_division_player_id')
    player_role = models.ForeignKey(PlayerRole, on_delete=models.DO_NOTHING, related_name='match_lineups', db_column='player_role_id')
    is_starter = models.BooleanField(default=True)
    in_at = models.TimeField(null=True, blank=True)
    out_at = models.TimeField(null=True, blank=True)
    is_finisher = models.BooleanField(null=True, blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        starter_status = "Starter" if self.is_starter else "Substitute"
        return f"{self.match} - {self.team_division_player.team_division.team.name}: {self.team_division_player.player.name}"

    class Meta:
        managed = False
        db_table = 'sports_matchlineup'
        ordering = ['team_division_player__team_division', '-is_starter', 'team_division_player__jersey_number']


class Event(models.Model):
    """Mirror model for sports.Event from Internal DB"""
    
    name = models.CharField(max_length=100, unique=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return self.name

    class Meta:
        managed = False
        db_table = 'sports_event'
        ordering = ['name']


class Subevent(models.Model):
    """Mirror model for sports.Subevent from Internal DB"""
    
    event = models.ForeignKey(Event, on_delete=models.DO_NOTHING, related_name='subevents', db_column='event_id')
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return f"{self.event.name} - {self.name}"

    class Meta:
        managed = False
        db_table = 'sports_subevent'
        ordering = ['event', 'name']


class Tag(models.Model):
    """Mirror model for sports.Tag from Internal DB"""
    
    name = models.CharField(max_length=100, unique=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return self.name

    class Meta:
        managed = False
        db_table = 'sports_tag'
        ordering = ['name']