from django.core.management.base import BaseCommand, CommandError
from django.core.files import File
from django.contrib.auth import get_user_model
from dispatch.models import Customer, Load, Identity, Paperwork
from faker import Faker
import random

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' --attachments=True"""

    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('--attachments', type=bool, dest='attachments', default=False)
        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']

        # customer_ids = []
        # user_ids = []

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

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

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

            # user_ids.append(u.pk)


        # We're going to go about getting the list of user and customer IDs
        # in a slightly different manner now so that we get _all_ customers
        # and _all_ users.
        customer_ids = self.get_customer_ids()
        user_ids = self.get_user_ids()

        for i in range(0, options['loads']):
            co_id = customer_ids[random.randint(0, len(customer_ids)-1)]
            co = Customer.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, options['attachments'])

    def fake_customer(self):
        new_customer = Customer(
                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_customer.save()
        return new_customer

    def fake_load(self, usr, co, attachments=False):
        fake_description = "{}-{} {} {}K".format(
            self.fake.month(), self.fake.day_of_month(),
            self.fake.license_plate(), random.randint(5, 50))
        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),
            description=fake_description,
            customer=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()

        if attachments:
            self.add_attachment(new_load)

        return new_load

    def add_attachment(self, load):
        p = Paperwork(load=load)
        p.document = File(open('chicken.pdf', 'rb'))
        p.save()


    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(),
                is_active=True
            )
            new_user.save()
            user_ident = Identity(
                user=new_user,
                name="{} {}".format(ffname, flname),
                address=self.fake.address(),
                city=self.fake.city(),
                state=self.fake.state(),
                zip_code=self.fake.zipcode(),
            )
            user_ident.save()
            return new_user
        except IntegrityError:
            # Around and around we go until we get something new
            return self.fake_user()


    def get_customer_ids(self):
        id_array = []
        for cus in Customer.objects.all():
            id_array.append(cus.pk)
        return id_array

    def get_user_ids(self):
        id_array = []
        for u in User.objects.all():
            id_array.append(u.pk)
        return id_array