import functools
import operator
from itertools import chain

import django.db.models.options as options
from django.conf import settings
from django.contrib.humanize.templatetags.humanize import intcomma
from django.db import models
from django.db.models import Q

options.DEFAULT_NAMES += 'gds_database',
GDS_URL = settings.GDS_URL


class GdsModelQuerySet(models.QuerySet):
    def active(self):
        fields_conditions = {
            'has_saved': {
                'has_saved': 1
            },
            'has_archived': {
                'has_archived': 0
            },
            'active': {
                'active': 1
            },
            'deleted_at': {
                'deleted_at__isnull': True
            }
        }
        model_conditions = {}
        for field in fields_conditions:
            if field in self.model._meta.get_all_field_names():
                model_conditions.update(fields_conditions[field])
        query_condition = functools.reduce(operator.and_, [Q(model_condition) for model_condition in
                                                           model_conditions.items()])
        return self.filter(query_condition)


class GdsModel(models.Model):
    objects = GdsModelQuerySet.as_manager()

    class Meta:
        abstract = True


class ArchiveTopics(GdsModel):
    reason = models.CharField(max_length=255)

    class Meta:
        managed = False
        db_table = 'archive_topics'
        gds_database = 'gds'


class Areas(GdsModel):
    name = models.CharField(max_length=255)
    plural_name = models.CharField(max_length=255)
    parent_area = models.ForeignKey('self', models.DO_NOTHING, blank=True, null=True)
    side = models.CharField(max_length=255)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by')
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    has_archived = models.IntegerField()
    archive_reason_topic = models.ForeignKey(ArchiveTopics, models.DO_NOTHING,
                                             db_column='archive_reason_topic', blank=True,
                                             null=True)
    archive_reason_freetext = models.TextField()

    class Meta:
        managed = False
        db_table = 'areas'
        gds_database = 'gds'


class AreasCategoriesLookup(GdsModel):
    area = models.ForeignKey(Areas, models.DO_NOTHING)
    category = models.ForeignKey('Categories', models.DO_NOTHING)

    class Meta:
        managed = False
        db_table = 'areas_categories_lookup'
        gds_database = 'gds'


class AreasMediaLookup(GdsModel):
    area = models.ForeignKey(Areas, models.DO_NOTHING)
    side_reference = models.CharField(max_length=50)
    media = models.ForeignKey('Medias', models.DO_NOTHING)

    class Meta:
        managed = False
        db_table = 'areas_media_lookup'
        gds_database = 'gds'


class BusinessHoldingGroups(GdsModel):
    name = models.CharField(max_length=100)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'business_holding_groups'


class Categories(GdsModel):  # CF
    cat_name = models.CharField(max_length=200)
    description = models.TextField()
    active = models.IntegerField(blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'categories'


class CategoriesCsLookup(GdsModel):
    category = models.ForeignKey(Categories, models.DO_NOTHING)
    cs = models.ForeignKey('Cs', models.DO_NOTHING, blank=True, null=True)
    cs_template = models.ForeignKey('CsTemplates', models.DO_NOTHING, blank=True, null=True)
    sort = models.IntegerField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'categories_cs_lookup'


class Cc(GdsModel):
    hashed_id = models.CharField(max_length=40)
    name = models.CharField(max_length=100)
    description = models.TextField()
    cog = models.ForeignKey('Co', models.DO_NOTHING, blank=True, null=True)
    active = models.IntegerField()
    required = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cc'


class Cg(GdsModel):  # Care Giver
    hashed_id = models.CharField(max_length=40)
    title = models.CharField(max_length=20)
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    nickname = models.CharField(max_length=50)
    pronoun = models.CharField(max_length=50)
    noun = models.CharField(max_length=50)
    description = models.TextField()
    active = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.IntegerField(blank=True, null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cg'

    def __str__(self):
        return self.title


class CgLookup(GdsModel):
    cg = models.ForeignKey(Cg, models.DO_NOTHING)
    fk_table = models.CharField(max_length=200)
    fk_id = models.IntegerField()
    pref = models.IntegerField()
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cg_lookup'


class CgQualifications(GdsModel):
    cg = models.ForeignKey(Cg, models.DO_NOTHING, related_name='qualifications')
    type = models.CharField(max_length=21)
    start_year = models.TextField()
    end_year = models.TextField()
    name = models.CharField(max_length=255)
    edu = models.ForeignKey('EducationOrganizations', models.DO_NOTHING, blank=True, null=True)
    city = models.ForeignKey('Cities', models.DO_NOTHING, blank=True, null=True)
    country = models.ForeignKey('Countries', models.DO_NOTHING, blank=True, null=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cg_qualifications'


class Cities(GdsModel):
    name = models.CharField(max_length=100)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cities'


class Cn(GdsModel):
    hashed_id = models.CharField(max_length=40)
    name = models.CharField(max_length=100)
    description = models.TextField()
    cog = models.ForeignKey('Co', models.DO_NOTHING, blank=True, null=True)
    active = models.IntegerField()
    required = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cn'


class Co(GdsModel):  # COG (is a category of Inventories)
    hashed_id = models.CharField(max_length=40)
    co = models.CharField(max_length=100)
    description = models.TextField()
    code = models.CharField(max_length=4, blank=True, null=True)
    active = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    rank = models.IntegerField()
    has_saved = models.IntegerField()
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'co'

    def __str__(self):
        return self.co


class CoCategoriesLookup(GdsModel):
    co = models.ForeignKey(Co, models.DO_NOTHING)
    category = models.ForeignKey(Categories, models.DO_NOTHING)

    class Meta:
        managed = False
        db_table = 'co_categories_lookup'
        gds_database = 'gds'


class CoCcLookup(GdsModel):
    co_id = models.IntegerField()
    cc_id = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'co_cc_lookup'
        gds_database = 'gds'


class CoCnLookup(GdsModel):
    co_id = models.IntegerField()
    cn_id = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'co_cn_lookup'
        gds_database = 'gds'


class CofCriteriaLookup(GdsModel):
    cof = models.ForeignKey('gds.Cof', models.DO_NOTHING)
    criteria = models.ForeignKey('CriteriaTypes', models.DO_NOTHING)
    set_value = models.CharField(max_length=255)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'cof_criteria_lookup'
        gds_database = 'gds'


class Complexities(GdsModel):
    complexity = models.CharField(max_length=150)
    complexity_type = models.ForeignKey('ComplexityTypes', models.DO_NOTHING, blank=True, null=True)
    active = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'complexities'


class ComplexityTypes(GdsModel):
    type = models.CharField(max_length=200, blank=True, null=True)
    active = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'complexity_types'


class Config(GdsModel):
    config_name = models.CharField(max_length=255)
    config_value = models.CharField(max_length=255)

    class Meta:
        managed = False
        db_table = 'config'
        gds_database = 'gds'


class Countries(GdsModel):
    country_code = models.CharField(max_length=2)
    country_name = models.CharField(max_length=45)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'countries'

    def __str__(self):
        return self.country_name


class Cp(GdsModel):  # care partner
    hashed_id = models.CharField(max_length=40)
    cp_name = models.CharField(max_length=100)
    destination = models.ForeignKey('Destinations', models.DO_NOTHING, db_column='destination',
                                    blank=True, null=True)
    description = models.TextField()
    code = models.CharField(max_length=4, blank=True, null=True)
    type = models.CharField(max_length=8, blank=True, null=True)
    bhg = models.ForeignKey(BusinessHoldingGroups, models.DO_NOTHING, blank=True, null=True)
    transfer_cp = models.CharField(max_length=10, blank=True, null=True)
    transfer_airport = models.CharField(max_length=10, blank=True, null=True)
    discount = models.CharField(max_length=10, blank=True, null=True)
    alt = models.IntegerField()
    active = models.IntegerField()
    rank = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cp'

    def __str__(self):
        return self.cp_name


class CpCategoriesLookup(GdsModel):
    cp = models.ForeignKey(Cp, models.DO_NOTHING)
    category = models.ForeignKey(Categories, models.DO_NOTHING)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cp_categories_lookup'


class CriteriaTypes(GdsModel):
    criteria = models.CharField(max_length=200)
    cost_driver = models.IntegerField(blank=True, null=True)
    active = models.IntegerField()
    private = models.IntegerField()
    rank = models.IntegerField(blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'criteria_types'


class Cs(GdsModel):
    name = models.CharField(max_length=255)
    type = models.CharField(max_length=11, blank=True, null=True)
    is_substep = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cs'

    def __str__(self):
        return self.name


class CsSubstepsLookup(GdsModel):
    cs = models.ForeignKey(Cs, models.DO_NOTHING, related_name="care_steps")
    substep = models.ForeignKey(Cs, models.DO_NOTHING)
    sort = models.IntegerField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cs_substeps_lookup'


class CsTemplateCs(GdsModel):
    cs = models.ForeignKey(Cs, models.DO_NOTHING)
    cs_template = models.ForeignKey('CsTemplates', models.DO_NOTHING)
    sort = models.IntegerField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cs_template_cs'


class CsTemplates(GdsModel):
    name = models.CharField(max_length=255)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cs_templates'


class Currency(GdsModel):
    country = models.ForeignKey(Countries, models.DO_NOTHING, db_column='country')
    currency = models.CharField(max_length=100, blank=True, null=True)
    currency_code = models.CharField(max_length=100)
    currency_symbol = models.CharField(max_length=100)
    active = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'currency'

    def __str__(self):
        return self.currency


class Destinations(GdsModel):
    hashed_id = models.CharField(max_length=40)
    country = models.ForeignKey(Countries, models.DO_NOTHING, blank=True, null=True)
    name = models.CharField(max_length=50)
    active = models.IntegerField()
    description = models.TextField()
    rank = models.IntegerField()
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'destinations'

    def __str__(self):
        return '{} - {}'.format(self.name, self.country)


class DiscountPolicies(GdsModel):
    cp = models.ForeignKey(Cp, models.DO_NOTHING)
    min_price = models.CharField(max_length=100)
    amount = models.CharField(max_length=100)
    category = models.ForeignKey(Categories, models.DO_NOTHING, blank=True, null=True)
    rule = models.CharField(max_length=255)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'discount_policies'


class EducationOrganizations(GdsModel):
    name = models.CharField(max_length=200)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'education_organizations'


class Inventory(GdsModel):  # also knows as Co

    argument_types = ['co.co']  # used for search

    hashed_id = models.CharField(max_length=40)
    cp = models.ForeignKey(Cp, models.DO_NOTHING, blank=True, null=True)
    co = models.ForeignKey(Co, models.DO_NOTHING, blank=True, null=True)
    cg = models.ForeignKey(Cg, models.DO_NOTHING, blank=True, null=True)
    min_price = models.DecimalField(max_digits=15, decimal_places=2)
    max_price = models.DecimalField(max_digits=15, decimal_places=2)
    preop = models.IntegerField()
    currency = models.ForeignKey(Currency, models.DO_NOTHING, blank=True, null=True)
    cat = models.ForeignKey(Categories, models.DO_NOTHING, blank=True, null=True)
    notes = models.CharField(max_length=255, blank=True, null=True)
    consultation = models.CharField(max_length=100, blank=True, null=True)
    planned_tests = models.CharField(max_length=100, blank=True, null=True)
    possible_tests = models.CharField(max_length=100, blank=True, null=True)
    type = models.CharField(max_length=3)
    night_icu = models.CharField(max_length=30, blank=True, null=True)
    night_hospital = models.CharField(max_length=30, blank=True, null=True)
    night_country = models.CharField(max_length=30, blank=True, null=True)
    active = models.IntegerField()
    package = models.IntegerField()
    promo = models.IntegerField()
    start_timestamp = models.DateTimeField(blank=True, null=True)
    end_timestamp = models.DateTimeField(blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    session_id = models.CharField(max_length=100)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by')
    has_saved = models.IntegerField()
    has_archived = models.IntegerField()
    archive_reason_topic = models.ForeignKey(ArchiveTopics, models.DO_NOTHING,
                                             db_column='archive_reason_topic', blank=True,
                                             null=True)
    archive_reason_freetext = models.TextField(blank=True, null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory'

    def __str__(self):
        if self.co:
            return self.co.co
        return 'Invalid inventory'

    def _yesno(self, val):
        answer = 'Y' if val else 'N'
        return answer

    def _string_to_bool(self, s):
        return len(s.strip()) > 0

    def is_available(self):
        return any([self._string_to_bool(self.get_cg()),
                    self._string_to_bool(self.get_cp_code())])

    def get_cp_code(self):
        if self.cp:
            return self.cp.code
        return ' '

    def get_co_name(self):
        if self.co:
            return self.co.co

    def get_package(self):
        return 'Package: {}'.format(self._yesno(self.package))

    def get_promo(self):
        return 'Promo: {}'.format(self._yesno(self.promo))

    def _format_price(self, price):
        decimal_part_formatted_price = "{0:.2f}".format(price)
        humanized_formatted_price = intcomma(decimal_part_formatted_price, use_l10n=False)
        return humanized_formatted_price.rstrip('0').rstrip(
            '.') if '.' in humanized_formatted_price else humanized_formatted_price

    def get_min_max_price(self):
        currency_symbol = ''
        currency_code = ''
        if self.currency:
            currency_symbol = self.currency.currency_symbol
            currency_code = self.currency.currency_code
        if self.min_price and self.max_price:
            return '{}{}-{} {}'.format(currency_symbol, self._format_price(self.min_price),
                                       self._format_price(self.max_price), currency_code)
        elif self.min_price:
            return '{}{} {}'.format(currency_symbol, self._format_price(self.min_price),
                                    currency_code)
        return ''

    def get_min_price(self):
        return 'MIN:{}'.format(self.min_price)

    def get_max_price(self):
        return 'MAX:{}'.format(self.max_price)

    def get_preop(self):
        return 'Pre-Op Incl: {}'.format(self._yesno(self.preop))

    def get_type(self):
        if self.type:
            return '{}: Y'.format(self.type)
        return ''

    def get_night_hospital(self):
        if self.night_hospital:
            return 'N/H: {}'.format(self.night_hospital)
        return ''

    def get_night_country(self):
        if self.night_country:
            return 'N/C: {}'.format(self.night_country)
        return ''

    def get_name(self):
        if self.co:
            return self.co.co
        return 'Name does not exist'

    def get_cg(self):
        if self.cg:
            return self.cg.first_name
        return ''

    def get_cp(self):
        if self.cp:
            return self.cp.cp_name
        return ''

    def get_owner(self):
        if self.cg and self.cp:
            return '{cg_title} {cg_first_name} ({cp_code})'.format(cg_title=self.cg.title,
                                                                   cg_first_name=self.cg.first_name,
                                                                   cp_code=self.cp.code)
        elif self.cg and not self.cp:
            return '{cg_title} {cg_first_name}'.format(cg_title=self.cg.title,
                                                       cg_first_name=self.cg.first_name)
        elif self.cp and not self.cg:
            return self.cp.code
        else:
            return 'Bad Inventory!'

    def get_price(self):
        currency_code = None
        if self.currency:
            currency_code = self.currency.currency_code
        if self.max_price:
            return '{}: {} - {}'.format(currency_code, self.min_price, self.max_price)
        return '{}: {}'.format(currency_code, self.min_price)

    def get_criteria_types(self):
        inventory_criteria_lookups = InventoryCriteriaLookup.objects.filter(inventory=self.id)
        criteria_types_ids = inventory_criteria_lookups.values_list('criteria', flat=True)
        return CriteriaTypes.objects.filter(id__in=criteria_types_ids).filter(cost_driver=1)

    def get_criteria_values(self):
        all_criterias = InventoryCriteriaLookup.objects.filter(inventory=self.id)
        criterias_with_costdriver_by_default = all_criterias.filter(
            Q(criteria__cost_driver=1) & (Q(cost_driver__isnull=True))
        )
        criterias_with_overrided_costdriver = all_criterias.filter(cost_driver=1)
        criterias_with_overrided_costdriver = sorted(criterias_with_overrided_costdriver,
                                                     key=lambda instance: instance.id)
        all_costdrivers_with_criteria = sorted(
            chain(criterias_with_costdriver_by_default, criterias_with_overrided_costdriver),
            key=lambda instance: instance.id)
        return all_costdrivers_with_criteria


class Cof(GdsModel):  # inventory fees
    hashed_id = models.CharField(max_length=40)
    name = models.CharField(max_length=255)
    co = models.ForeignKey(Co, models.DO_NOTHING, blank=True, null=True)
    cp = models.ForeignKey('Cp', models.DO_NOTHING, blank=True, null=True)
    cg = models.ForeignKey(Cg, models.DO_NOTHING, blank=True, null=True)
    min_price = models.CharField(max_length=100)
    max_price = models.CharField(max_length=100)
    currency = models.ForeignKey('Currency', models.DO_NOTHING, blank=True, null=True)
    cat = models.ForeignKey(Categories, models.DO_NOTHING, blank=True, null=True)
    notes = models.CharField(max_length=255)
    type = models.CharField(max_length=3)
    night_hospital = models.CharField(max_length=30)
    night_country = models.CharField(max_length=30)
    active = models.IntegerField()
    package = models.IntegerField()
    promo = models.IntegerField()
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by')
    start_timestamp = models.DateTimeField(blank=True, null=True)
    end_timestamp = models.DateTimeField(blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'cof'


class InventoryCcoLookup(GdsModel):
    inventory = models.ForeignKey(Inventory, models.DO_NOTHING)
    co = models.ForeignKey(Co, models.DO_NOTHING)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory_cco_lookup'


class InventoryCofLookup(GdsModel):
    inventory = models.ForeignKey(Inventory, models.DO_NOTHING)
    cof = models.ForeignKey(Cof, models.DO_NOTHING)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory_cof_lookup'


class InventoryComplexitiesLookup(GdsModel):
    complexity = models.ForeignKey(Complexities, models.DO_NOTHING)
    inventory = models.ForeignKey(Inventory, models.DO_NOTHING)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory_complexities_lookup'


class InventoryCriteriaLookup(GdsModel):
    inventory = models.ForeignKey(Inventory, models.DO_NOTHING)
    criteria = models.ForeignKey(CriteriaTypes, models.DO_NOTHING)
    set_value = models.CharField(max_length=255)
    cost_driver = models.IntegerField(blank=True, null=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    def __str__(self):
        return '{}: {}'.format(self.criteria.criteria, self.set_value)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory_criteria_lookup'


class InventorySources(GdsModel):
    inventory = models.ForeignKey(Inventory, models.DO_NOTHING)
    name = models.CharField(max_length=255, blank=True, null=True)
    source = models.CharField(max_length=20, blank=True, null=True)
    stamp = models.DateField(blank=True, null=True)
    found_user = models.ForeignKey('Users', models.DO_NOTHING, blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'inventory_sources'


class Knowledge(GdsModel):
    hashed_id = models.CharField(max_length=40)
    knowledge = models.TextField()
    updated_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='updated_by', blank=True,
                                   null=True)
    has_archived = models.IntegerField()
    archive_reason_topic = models.ForeignKey(ArchiveTopics, models.DO_NOTHING,
                                             db_column='archive_reason_topic', blank=True,
                                             null=True)
    archive_reason_freetext = models.TextField(blank=True, null=True)
    is_moderated = models.IntegerField()
    email_sent = models.IntegerField()
    updated_at = models.DateTimeField()
    created_at = models.DateTimeField()

    class Meta:
        managed = False
        db_table = 'knowledge'
        gds_database = 'gds'


class KnowledgeMediaLookup(GdsModel):
    knowledge = models.ForeignKey(Knowledge, models.DO_NOTHING)
    custom_file_name = models.CharField(max_length=255)
    media = models.ForeignKey('Medias', models.DO_NOTHING)

    class Meta:
        managed = False
        db_table = 'knowledge_media_lookup'
        gds_database = 'gds'


class KnowledgeSources(GdsModel):
    knowledge = models.ForeignKey(Knowledge, models.DO_NOTHING)
    name = models.CharField(max_length=255, blank=True, null=True)
    source = models.CharField(max_length=20, blank=True, null=True)
    stamp = models.DateField(blank=True, null=True)
    found_user = models.ForeignKey('Users', models.DO_NOTHING, blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'knowledge_sources'
        gds_database = 'gds'


class MediaLookup(GdsModel):
    fk_table = models.CharField(max_length=200)
    fk_id = models.IntegerField()
    media = models.ForeignKey('Medias', models.DO_NOTHING)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'media_lookup'


class MediaTypes(GdsModel):
    content_type = models.CharField(max_length=50)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'media_types'


class Medias(GdsModel):
    content_url = models.CharField(max_length=512)
    media_type = models.ForeignKey(MediaTypes, models.DO_NOTHING, blank=True, null=True)
    extension_type = models.CharField(max_length=5, blank=True, null=True)
    caption = models.CharField(max_length=255)
    is_title_photo = models.IntegerField()
    is_logo = models.IntegerField()
    is_profile = models.IntegerField()
    is_icon = models.IntegerField()
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by')
    deleted_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'medias'


class Migrations(GdsModel):
    migration = models.CharField(max_length=255)
    batch = models.IntegerField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'migrations'


class PasswordResets(GdsModel):
    email = models.CharField(max_length=255)
    token = models.CharField(max_length=255)
    created_at = models.DateTimeField()

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'password_resets'


class Questions(GdsModel):  # CA
    hashed_id = models.CharField(max_length=40)
    question = models.TextField()
    rnu = models.IntegerField()
    answer = models.TextField()
    active = models.IntegerField()
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)
    added_by = models.ForeignKey('Users', models.DO_NOTHING, db_column='added_by', blank=True,
                                 null=True)
    new_record_notification_sent = models.IntegerField()
    deleted_at = models.DateTimeField(blank=True, null=True)

    def get_answer_link(self):
        return '{}/answers?id={}'.format(GDS_URL, self.hashed_id)

    def __str__(self):
        return '{}'.format(self.question)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'questions'


class QuestionsLookup(GdsModel):
    question = models.ForeignKey(Questions, models.DO_NOTHING)
    fk_table = models.CharField(max_length=200)
    fk_id = models.IntegerField()
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'questions_lookup'


class TransferPoliciesAirport(GdsModel):
    cp = models.ForeignKey(Cp, models.DO_NOTHING)
    airport_code = models.CharField(max_length=15)
    min_price = models.CharField(max_length=100)
    status = models.CharField(max_length=3)
    restriction = models.CharField(max_length=255)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'transfer_policies_airport'


class TransferPoliciesCp(GdsModel):
    cp = models.ForeignKey(Cp, models.DO_NOTHING)
    min_price = models.CharField(max_length=100)
    status = models.CharField(max_length=3)
    restriction = models.CharField(max_length=255)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'transfer_policies_cp'


class Userroles(GdsModel):
    role = models.CharField(max_length=50)
    role_safe = models.CharField(max_length=50)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'userroles'


class Users(GdsModel):
    role = models.ForeignKey(Userroles, models.DO_NOTHING, blank=True, null=True)
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.CharField(unique=True, max_length=255)
    username = models.CharField(unique=True, max_length=100)
    password = models.CharField(max_length=60)
    active = models.IntegerField()
    remember_token = models.CharField(max_length=100, blank=True, null=True)
    created_at = models.DateTimeField()
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        gds_database = 'gds'
        db_table = 'users'


def get_medias_for(fk_table, fk_id, media_filter_options={}):
    media_lookups = MediaLookup.objects.filter(fk_table=fk_table, fk_id=fk_id)
    media_ids = media_lookups.values_list('media', flat=True)
    medias = Medias.objects.filter(id__in=media_ids, **media_filter_options)
    return medias