from django.conf import settings
from django.db import models
from django.urls import reverse
from django.utils.text import slugify


class Company(models.Model):
    class Tier(models.TextChoices):
        FREE = 'free', 'Free'
        STARTER = 'starter', 'Starter'
        PRO = 'pro', 'Professional'
        PREMIUM = 'premium', 'Premium'
        ENTERPRISE = 'enterprise', 'Enterprise'

    class Size(models.TextChoices):
        S1 = '1-10', '1–10 employees'
        S2 = '11-50', '11–50 employees'
        S3 = '51-200', '51–200 employees'
        S4 = '201-500', '201–500 employees'
        S5 = '501-1000', '501–1,000 employees'
        S6 = '1001-5000', '1,001–5,000 employees'
        S7 = '5000+', '5,000+ employees'

    class CompanyType(models.TextChoices):
        PRIVATE = 'private', 'Private Company'
        PUBLIC = 'public', 'Public Company'
        GOVERNMENT = 'government', 'Government'
        NGO = 'ngo', 'NGO / Non-Profit'
        INTERNATIONAL = 'international', 'International Organisation'
        STARTUP = 'startup', 'Startup'
        SME = 'sme', 'SME'
        EDUCATION = 'education', 'Educational Institution'
        OTHER = 'other', 'Other'

    class ApplicationDelivery(models.TextChoices):
        ATS = 'ats', 'Through PEZAJOB (ATS)'
        EMAIL = 'email', 'To my company email'

    name = models.CharField(max_length=150)
    slug = models.SlugField(max_length=170, unique=True)
    initials = models.CharField(max_length=4)
    logo_gradient = models.CharField(
        max_length=120,
        default='linear-gradient(135deg,#2c3e50,#34495e)',
    )
    industry = models.CharField(max_length=100)
    industry_slug = models.SlugField(max_length=120, blank=True)
    sub_industry = models.CharField(max_length=150, blank=True)
    location = models.CharField(max_length=120)
    employee_count_display = models.CharField(max_length=60, blank=True)
    company_size = models.CharField(max_length=20, choices=Size.choices, blank=True)
    company_type = models.CharField(max_length=20, choices=CompanyType.choices, blank=True)
    short_description = models.CharField(max_length=300, blank=True)
    specializations = models.TextField(blank=True, help_text='One per line')
    country = models.CharField(max_length=80, blank=True, default='Zambia')
    province = models.CharField(max_length=80, blank=True)
    city = models.CharField(max_length=100, blank=True)
    address = models.CharField(max_length=255, blank=True)
    other_locations = models.TextField(blank=True, help_text='One per line')
    recruitment_email = models.EmailField(blank=True)
    recruitment_phone = models.CharField(max_length=30, blank=True)
    facebook_url = models.URLField(blank=True)
    x_url = models.URLField(blank=True)
    instagram_url = models.URLField(blank=True)
    youtube_url = models.URLField(blank=True)
    careers_overview = models.TextField(blank=True)
    offers_internships = models.BooleanField(default=False)
    offers_graduate_roles = models.BooleanField(default=False)
    offers_trainee_programmes = models.BooleanField(default=False)
    offers_apprenticeships = models.BooleanField(default=False)
    recruits_experienced = models.BooleanField(default=False)
    why_work_with_us = models.TextField(blank=True)
    culture = models.TextField(blank=True)
    values = models.TextField(blank=True, help_text='One per line')
    benefits = models.TextField(blank=True, help_text='One per line')
    registered_name = models.CharField(max_length=200, blank=True)
    registration_number = models.CharField(max_length=80, blank=True)
    registration_country = models.CharField(max_length=80, blank=True)
    registration_document = models.FileField(upload_to='companies/verification/', max_length=255, blank=True, null=True)
    rep_name = models.CharField(max_length=120, blank=True)
    rep_position = models.CharField(max_length=120, blank=True)
    rep_email = models.EmailField(blank=True)
    rep_phone = models.CharField(max_length=30, blank=True)
    cover_image_url = models.URLField(blank=True)
    cover_image = models.ImageField(upload_to='companies/covers/', max_length=255, blank=True, null=True)
    website = models.URLField(blank=True)
    email = models.EmailField(blank=True)
    phone = models.CharField(max_length=30, blank=True)
    linkedin_url = models.URLField(blank=True)
    application_delivery_method = models.CharField(
        max_length=10,
        choices=ApplicationDelivery.choices,
        default=ApplicationDelivery.EMAIL,
        help_text='How you want to receive job applications, when your plan includes ATS access.',
    )
    founded_year = models.PositiveIntegerField(null=True, blank=True)
    description = models.TextField()
    tags = models.TextField(blank=True, help_text='One tag per line')
    tier = models.CharField(max_length=20, choices=Tier.choices, default=Tier.FREE)
    rating = models.DecimalField(max_digits=2, decimal_places=1, null=True, blank=True)
    review_count = models.PositiveIntegerField(default=0)
    successful_hires = models.PositiveIntegerField(default=0)
    is_featured = models.BooleanField(default=False)
    is_public = models.BooleanField(
        default=True,
        help_text='When off, your company page is hidden from the directory and public URL.',
    )
    is_online = models.BooleanField(
        default=True,
        help_text='When off, your company appears as offline and is hidden from the homepage carousel.',
    )
    is_active = models.BooleanField(default=True)
    owner = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name='companies',
    )
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ['-is_featured', 'name']
        verbose_name_plural = 'companies'

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        if not self.industry_slug:
            self.industry_slug = slugify(self.industry)
        super().save(*args, **kwargs)

    def get_absolute_url(self):
        return reverse('companies:detail', kwargs={'slug': self.slug})

    @property
    def tag_list(self):
        import re
        return [part.strip() for part in re.split(r'[\n\r;,]+', self.tags or '') if part.strip()]

    @staticmethod
    def _lines(text):
        import re
        return [part.strip() for part in re.split(r'[\n\r;]+', text or '') if part.strip()]

    @property
    def specialization_list(self):
        return self._lines(self.specializations)

    @property
    def other_location_list(self):
        return self._lines(self.other_locations)

    @property
    def value_list(self):
        return self._lines(self.values)

    @property
    def benefit_list(self):
        return self._lines(self.benefits)

    @property
    def hiring_programmes(self):
        pairs = [
            (self.offers_internships, 'Internships'),
            (self.offers_graduate_roles, 'Graduate opportunities'),
            (self.offers_trainee_programmes, 'Graduate trainee programmes'),
            (self.offers_apprenticeships, 'Apprenticeships'),
            (self.recruits_experienced, 'Experienced professionals'),
        ]
        return [label for on, label in pairs if on]

    @property
    def card_tags(self):
        """Up to three short labels for cards: tags, falling back to specializations."""
        return (self.tag_list or self.specialization_list or [t for t in (self.sub_industry,) if t])[:3]

    @property
    def is_verified(self):
        """True once the company has supplied its registration details."""
        return bool(self.registered_name and self.registration_number)

    @property
    def summary(self):
        return self.short_description or self.description

    @property
    def is_premium_tier(self):
        return self.tier in {self.Tier.PREMIUM, self.Tier.ENTERPRISE}

    @property
    def employees_display(self):
        """Team size to show publicly: the free-text field if set, else the size range."""
        if self.employee_count_display:
            return self.employee_count_display
        if self.company_size:
            return self.get_company_size_display()
        return ''

    @property
    def presence_label(self):
        return 'Online' if self.is_online else 'Offline'

    @property
    def presence_css_class(self):
        return 'online' if self.is_online else 'offline'

    @property
    def uploaded_cover_url(self):
        if self.cover_image:
            try:
                return self.cover_image.url
            except (ValueError, AttributeError):
                pass
        return ''

    @property
    def display_cover_url(self):
        from home.cover_images import is_demo_image_url

        uploaded = self.uploaded_cover_url
        if uploaded:
            return uploaded
        url = (self.cover_image_url or '').strip()
        if url and not is_demo_image_url(url):
            return url
        return ''

    @property
    def display_logo_url(self):
        if self.owner_id and getattr(self.owner, 'avatar', None):
            try:
                if self.owner.avatar:
                    return self.owner.avatar.url
            except (ValueError, AttributeError):
                pass
        return ''

    @property
    def years_active(self):
        if self.founded_year:
            from datetime import date
            return date.today().year - self.founded_year
        return None

    @property
    def follower_count(self):
        return self.followers.count()


class CompanyFollow(models.Model):
    """Seeker follows a company for job and profile update alerts."""

    user = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.CASCADE,
        related_name='company_follows',
    )
    company = models.ForeignKey(
        Company,
        on_delete=models.CASCADE,
        related_name='followers',
    )
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ['-created_at']
        constraints = [
            models.UniqueConstraint(fields=['user', 'company'], name='unique_company_follow'),
        ]

    def __str__(self):
        return f'{self.user_id} follows {self.company.name}'


class CompanyProduct(models.Model):
    company = models.ForeignKey(Company, on_delete=models.CASCADE, related_name='products')
    name = models.CharField(max_length=150)
    description = models.TextField(blank=True)
    image = models.ImageField(upload_to='companies/products/', max_length=255, blank=True, null=True)
    position = models.PositiveIntegerField(default=0)

    class Meta:
        ordering = ['position', 'id']

    def __str__(self):
        return f'{self.company.name}: {self.name}'


class CompanyPhoto(models.Model):
    company = models.ForeignKey(Company, on_delete=models.CASCADE, related_name='photos')
    image = models.ImageField(upload_to='companies/gallery/', max_length=255)
    caption = models.CharField(max_length=160, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ['-created_at', '-id']

    def __str__(self):
        return f'{self.company.name} photo {self.pk}'