import json

from django.conf import settings as s
from django.core.management.base import BaseCommand
from django.db import transaction

from epdb.logic import UserManager, GroupManager, PackageManager, SettingManager
from epdb.models import UserSettingPermission, MLRelativeReasoning, EnviFormer, Permission, User


class Command(BaseCommand):

    def create_users(self):

        if not User.objects.filter(email='anon@lorsba.ch').exists():
            anon = UserManager.create_user("anonymous", "anon@lorsba.ch", "SuperSafe", is_active=True,
                                           add_to_group=False, set_setting=False)
        else:
            anon = User.objects.get(email='anon@lorsba.ch')

        if not User.objects.filter(email='admin@lorsba.ch').exists():
            admin = UserManager.create_user("admin", "admin@lorsba.ch", "SuperSafe", is_active=True, add_to_group=False,
                                            set_setting=False)
            admin.is_staff = True
            admin.is_superuser = True
            admin.save()
        else:
            admin = User.objects.get(email='admin@lorsba.ch')

        g = GroupManager.create_group(admin, 'enviPath Users', 'All enviPath Users')
        g.public = True
        g.save()

        g.user_member.add(anon)
        g.save()

        anon.default_group = g
        anon.save()

        admin.default_group = g
        admin.save()

        if not User.objects.filter(email='jebus@lorsba.ch').exists():
            jebus = UserManager.create_user("jebus", "jebus@lorsba.ch", "SuperSafe", is_active=True, add_to_group=False,
                                            set_setting=False)
            jebus.is_staff = True
            jebus.is_superuser = True
            jebus.save()
        else:
            jebus = User.objects.get(email='jebus@lorsba.ch')

        g.user_member.add(jebus)
        g.save()

        jebus.default_group = g
        jebus.save()

        return anon, admin, g, jebus

    def import_package(self, data, owner):
        return PackageManager.import_package(data, owner, keep_ids=True)

    def create_default_setting(self, owner, packages):
        s = SettingManager.create_setting(
            owner,
            name='Global Default Setting',
            description='Global Default Setting containing BBD Rules and Max 30 Nodes and Max Depth of 8',
            max_nodes=30,
            max_depth=5,
            rule_packages=packages,
            model=None,
            model_threshold=None
        )

        return s

    @transaction.atomic
    def handle(self, *args, **options):
        # Create users
        anon, admin, g, jebus = self.create_users()

        # Import Packages
        packages = [
            'EAWAG-BBD.json',
            'EAWAG-SOIL.json',
            'EAWAG-SLUDGE.json',
            'EAWAG-SEDIMENT.json',
        ]

        mapping = {}
        for p in packages:
            print(f"Importing {p}...")
            package_data = json.loads(open(s.BASE_DIR / 'fixtures' / 'packages' / '2025-07-18' / p).read())
            imported_package = self.import_package(package_data, admin)
            mapping[p.replace('.json', '')] = imported_package

        setting = self.create_default_setting(admin, [mapping['EAWAG-BBD']])
        setting.public = True
        setting.save()
        setting.make_global_default()

        for u in [anon, jebus]:
            u.default_setting = setting
            u.save()

            usp = UserSettingPermission()
            usp.user = u
            usp.setting = setting
            usp.permission = Permission.READ[0]
            usp.save()

        # Create Model Package
        pack = PackageManager.create_package(admin, "Public Prediction Models",
                                             "Package to make Prediction Models publicly available")
        pack.reviewed = True
        pack.save()

        # Create RR
        ml_model = MLRelativeReasoning.create(
            pack,
            'ECC - BBD - T0.5',
            'ML Relative Reasoning',
            [mapping['EAWAG-BBD']],
            [mapping['EAWAG-BBD']],
            [],
            0.5
        )

        X, y = ml_model.build_dataset()
        ml_model.build_model(X, y)
        # ml_model.evaluate_model()

        # If available create EnviFormerModel
        if s.ENVIFORMER_PRESENT:
            enviFormer_model = EnviFormer.create(pack, 'EnviFormer - T0.5', 'EnviFormer Model with Threshold 0.5', 0.5)