from django.core.management.base import BaseCommand, CommandError
from django.contrib.auth import get_user_model
from dispatch.models import Company, Load
from faker import Faker
from datetime import date, timedelta
import random

# So we can check if a user already exists
from django.core.exceptions import ObjectDoesNotExist
from django.db.utils import IntegrityError

# import yaml

User = get_user_model()

class Command(BaseCommand):
    help = """Generate fake data.\n
    Example usage: \n
   ./manage.py insert_fake_data --companies 4 --users 3 --loads 800 --start-date='-16w' --end-date '+16w' 
    """

    fake = Faker()
    end_date=""
    start_date=""

    def add_arguments(self, parser):
        # parser.add_argument('--file', type=str, dest='filename')
        parser.add_argument('--companies', type=int, dest='companies', default='0')
        parser.add_argument('--users', type=int, dest='users', default='0')
        parser.add_argument('--loads', type=int, dest='loads', default='0')
        parser.add_argument('--start-date', type=str, dest='startdate', default='-2w')
        parser.add_argument('--end-date', type=str, dest='enddate', default='+2w')


    def handle(self, *args, **options):

        self.end_date=options['enddate']
        self.start_date=options['startdate']

        company_ids = []
        user_ids = []

        for i in range(0, options['companies']):
            co = self.fake_company()

            # We're going to hold the model IDs in memory to access randomly
            # later on
            company_ids.append(co.pk)

        for i in range(0, options['users']):
            u = self.fake_user()

            user_ids.append(u.pk)

        for i in range(0, options['loads']):
            co_id = company_ids[random.randint(0, len(company_ids)-1)]
            co = Company.objects.get(pk=co_id)

            u_id = user_ids[random.randint(0, len(user_ids)-1)]
            u = User.objects.get(pk=u_id)

            l = self.fake_load(u, co)


    def fake_company(self):
        new_company = Company(
                name = self.fake.company(),
                address = self.fake.address(),
                phone_number = self.fake.msisdn(),
                email_address = self.fake.company_email(),
                contact_name = self.fake.name(),
            )
        new_company.save()
        return new_company

    def fake_load(self, usr, co):
        new_load = Load(
            user=usr,
            # Because that's going to be random enough
            load_number=self.fake.license_plate(),
            description=self.fake.sentence(nb_words=6),
            company=co,
            amount=random.randint(150,2500),
            delivered_to=self.fake.city(),
        )
        # Set the date to something random between last week and next week
        new_load.date=self.fake.date_between(start_date=self.start_date, end_date=self.end_date)
        new_load.save()
        return new_load


    def fake_user(self):
        ffname = self.fake.first_name()
        flname = self.fake.last_name()
        funame = ffname[0] + flname
        funame = '%s.%s' % (ffname, flname)

        try: 
            new_user = User(
                first_name=ffname,
                last_name=flname,
                email=self.fake.email(),
                # Set the fake user name to be the first initial and last name
                username=funame,
                is_active=True
            )
            new_user.save()
            return new_user
        except IntegrityError:
            # Around and around we go until we get something new
            return self.fake_user()