package com.sgs;

import com.sgs.graphql.activitySubUnit.domain.ActivitySubUnit;
import com.sgs.graphql.activitySubUnit.service.ActivitySubUnitService;
import com.sgs.graphql.area.domain.Area;
import com.sgs.graphql.area.service.AreaService;
import com.sgs.graphql.city.domain.City;
import com.sgs.graphql.city.repo.CityRepo;
import com.sgs.graphql.city.service.CityService;
import com.sgs.graphql.consuptionUnit.domain.ConsuptionUnit;
import com.sgs.graphql.consuptionUnit.repo.ConsuptionUnitRepo;
import com.sgs.graphql.consuptionUnit.service.ConsuptionUnitService;
import com.sgs.graphql.country.domain.Country;
import com.sgs.graphql.country.repo.CountryRepo;
import com.sgs.graphql.country.service.CountryService;
import com.sgs.graphql.district.domain.District;
import com.sgs.graphql.district.repo.DistrictRepo;
import com.sgs.graphql.district.service.DistrictService;
import com.sgs.graphql.emissionScope.domain.EmissionScope;
import com.sgs.graphql.emissionScope.service.EmissionScopeService;
import com.sgs.graphql.emissionSource.domain.EmissionSource;
import com.sgs.graphql.emissionSource.repo.EmissionSourceRepo;
import com.sgs.graphql.emissionSource.service.EmissionSourceService;
import com.sgs.graphql.emissionSourceConvertUnits.domain.EmissionSourceConvertUnit;
import com.sgs.graphql.emissionSourceConvertUnits.service.EmissionSourceConvertUnitService;
import com.sgs.graphql.gpcReference.domain.GpcReference;
import com.sgs.graphql.gpcReference.service.GpcReferenceService;
import com.sgs.graphql.mail.domain.MailInfo;
import com.sgs.graphql.mail.service.MailInfoService;
import com.sgs.graphql.mcfType.domain.McfType;
import com.sgs.graphql.mcfType.service.McfTypeService;
import com.sgs.graphql.neighborhood.domain.Neighborhood;
import com.sgs.graphql.neighborhood.repo.NeighborhoodRepo;
import com.sgs.graphql.neighborhood.service.NeighborhoodService;
import com.sgs.graphql.organization.domain.Organization;
import com.sgs.graphql.organization.service.OrganizationService;
import com.sgs.graphql.permission.domain.Permission;
import com.sgs.graphql.permission.domain.PermissionDescription;
import com.sgs.graphql.permission.domain.PermissionName;
import com.sgs.graphql.permission.service.PermissionService;
import com.sgs.graphql.role.domain.Role;
import com.sgs.graphql.role.repo.RoleRepo;
import com.sgs.graphql.role.service.RoleService;
import com.sgs.graphql.sector.domain.Sector;
import com.sgs.graphql.sector.service.SectorService;
import com.sgs.graphql.solidWasteType.domain.SolidWasteType;
import com.sgs.graphql.solidWasteType.service.SolidWasteTypeService;
import com.sgs.graphql.subSector.domain.SubSector;
import com.sgs.graphql.subSector.repo.SubSectorRepo;
import com.sgs.graphql.subSector.service.SubSectorService;
import com.sgs.graphql.user.domain.User;
import com.sgs.graphql.user.service.UserService;
import com.sgs.graphql.wasteEmissionSource.domain.WasteEmissionSourceSupplement;
import com.sgs.graphql.wasteEmissionSource.service.WasteEmissionSourceSupplementService;

import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;

@SpringBootApplication
public class SgsApplication implements CommandLineRunner {

    private final PermissionService permissionService;
    private final RoleService roleService;
    private final RoleRepo roleRepo;
    private final AreaService areaService;
    private final NeighborhoodRepo neighborhoodRepo;
    private final NeighborhoodService neighborhoodService;
    private final CityService cityService;
    private final CityRepo cityRepo;
    private final DistrictRepo districtRepo;
    private final DistrictService districtService;
    private final CountryRepo countryRepo;
    private final CountryService countryService;
    private final OrganizationService organizationService;
    private final UserService userService;
    private final PasswordEncoder passwordEncoder;
    private final SectorService sectorService;
    private final SubSectorService subSectorService;
    private final EmissionScopeService emissionScopeService;
    private final GpcReferenceService gpcReferenceService;
    private final SubSectorRepo subSectorRepo;
    private final ActivitySubUnitService activitySubUnitService;
    private final ConsuptionUnitService consuptionUnitService;
    private final EmissionSourceService emissionSourceService;
    private final EmissionSourceRepo emissionSourceRepo;
    private final ConsuptionUnitRepo consuptionUnitRepo;
    private final EmissionSourceConvertUnitService emissionSourceConvertUnitService;
    private final SolidWasteTypeService solidWasteTypeService;
    private final McfTypeService mcfTypeService;
    private final WasteEmissionSourceSupplementService wasteEmissionSourceSupplementService;
    private final MailInfoService mailInfoService;

    @Value("${mail.hostname:mail.blc-css.com}")
    private String mailHostname;

    @Value("${mail.smtp.port:465}")
    private int mailSmtpPort;

    @Value("${mail.address:info@blc-css.com}")
    private String mailAddress;

    @Value("${mail.password:}")
    private String mailPassword;

    public static void main(String[] args) {
        SpringApplication.run(SgsApplication.class, args);
    }

    @Autowired
    public SgsApplication(RoleService roleService, PermissionService permissionService, RoleRepo roleRepo,
            AreaService areaService, NeighborhoodRepo neighborhoodRepo, NeighborhoodService neighborhoodService,
            CityService cityService,
            CityRepo cityRepo, DistrictRepo districtRepo, DistrictService districtService, CountryRepo countryRepo,
            CountryService countryService, OrganizationService organizationService, UserService userService,
            PasswordEncoder passwordEncoder, SectorService sectorService, SubSectorService subSectorService,
            EmissionScopeService emissionScopeService, GpcReferenceService gpcReferenceService,
            SubSectorRepo subSectorRepo, ActivitySubUnitService activitySubUnitService,
            ConsuptionUnitService consuptionUnitService, EmissionSourceService emissionSourceService,
            EmissionSourceRepo emissionSourceRepo, ConsuptionUnitRepo consuptionUnitRepo,
            EmissionSourceConvertUnitService emissionSourceConvertUnitService,
            SolidWasteTypeService solidWasteTypeService, McfTypeService mcfTypeService,
            WasteEmissionSourceSupplementService wasteEmissionSourceSupplementService,
            MailInfoService mailInfoService) {
        this.roleService = roleService;
        this.permissionService = permissionService;
        this.roleRepo = roleRepo;
        this.areaService = areaService;
        this.neighborhoodRepo = neighborhoodRepo;
        this.neighborhoodService = neighborhoodService;
        this.cityService = cityService;
        this.cityRepo = cityRepo;
        this.districtRepo = districtRepo;
        this.districtService = districtService;
        this.countryRepo = countryRepo;
        this.countryService = countryService;
        this.organizationService = organizationService;
        this.userService = userService;
        this.passwordEncoder = passwordEncoder;
        this.sectorService = sectorService;
        this.subSectorService = subSectorService;
        this.emissionScopeService = emissionScopeService;
        this.gpcReferenceService = gpcReferenceService;
        this.subSectorRepo = subSectorRepo;
        this.activitySubUnitService = activitySubUnitService;
        this.consuptionUnitService = consuptionUnitService;
        this.emissionSourceService = emissionSourceService;
        this.emissionSourceRepo = emissionSourceRepo;
        this.consuptionUnitRepo = consuptionUnitRepo;
        this.emissionSourceConvertUnitService = emissionSourceConvertUnitService;
        this.solidWasteTypeService = solidWasteTypeService;
        this.mcfTypeService = mcfTypeService;
        this.wasteEmissionSourceSupplementService = wasteEmissionSourceSupplementService;
        this.mailInfoService = mailInfoService;
    }

    void createDefaultOrganization() {
        Organization organization = new Organization();
        organization.setTag("BLC");
        organization.setDescription("BLC Communication and Security Systems");
        organizationService.save(organization);
    }

    void createDefaultUser() {
        Role role = roleRepo.findByTag("SUPER_ADMIN").orElse(null);
        List<Permission> permissions = new ArrayList<>();
        if (!permissionService.findAll().isEmpty()) {
            permissions.addAll(permissionService.findAll());
        }
        role.setPermissions(permissions);

        // List<Organization> organizations = organizationRepo.findByTag("BLC");

        User admin = new User();
        admin.setFirstName("Seda");
        admin.setLastName("Kemikli");
        admin.setEmail("seda.kemikli@blc-css.com");
        admin.setPhoneNumber("11111511");
        admin.setPassword(passwordEncoder.encode("admin"));
        // if (organizations.size() == 1) {
        // admin.setOrganizations(organizations);
        // }
        admin.setRole(role);
        admin.setStatus("aktif");
        userService.save(admin);
    }

    public void createDefaultPermission() {

        Permission activities_get = new Permission();
        activities_get.setTag(PermissionName.ACTIVITIES_GET);
        activities_get.setDescription(PermissionDescription.ACTIVITIES_GET);

        Permission paginate_user_histories = new Permission();
        paginate_user_histories.setTag(PermissionName.PAGINATE_USER_HISTORIES);
        paginate_user_histories.setDescription(PermissionDescription.PAGINATE_USER_HISTORIES);

        Permission activity_sub_units_get = new Permission();
        activity_sub_units_get.setTag(PermissionName.ACTIVITY_SUB_UNITS_GET);
        activity_sub_units_get.setDescription(PermissionDescription.ACTIVITY_SUB_UNITS_GET);

        Permission sub_sectors_get = new Permission();
        sub_sectors_get.setTag(PermissionName.SUB_SECTORS_GET);
        sub_sectors_get.setDescription(PermissionDescription.SUB_SECTORS_GET);

        Permission sectors_get = new Permission();
        sectors_get.setTag(PermissionName.SECTORS_GET);
        sectors_get.setDescription(PermissionDescription.SECTORS_GET);

        Permission deleted_items = new Permission();
        deleted_items.setTag(PermissionName.GET_DELETED_ITEMS);
        deleted_items.setDescription(PermissionDescription.GET_DELETED_ITEMS);

        Permission user_create = new Permission();
        user_create.setTag(PermissionName.USER_CREATE);
        user_create.setDescription(PermissionDescription.USER_CREATE);

        Permission user_update = new Permission();
        user_update.setTag(PermissionName.USER_UPDATE);
        user_update.setDescription(PermissionDescription.USER_UPDATE);

        Permission user_delete = new Permission();
        user_delete.setTag(PermissionName.USER_DELETE);
        user_delete.setDescription(PermissionDescription.USER_DELETE);

        Permission paginate_users_get = new Permission();
        paginate_users_get.setTag(PermissionName.PAGINATE_USERS_GET);
        paginate_users_get.setDescription(PermissionDescription.PAGINATE_USERS_GET);

        Permission role_create = new Permission();
        role_create.setTag(PermissionName.ROLE_CREATE);
        role_create.setDescription(PermissionDescription.ROLE_CREATE);

        Permission role_update = new Permission();
        role_update.setTag(PermissionName.ROLE_UPDATE);
        role_update.setDescription(PermissionDescription.ROLE_UPDATE);

        Permission role_delete = new Permission();
        role_delete.setTag(PermissionName.ROLE_DELETE);
        role_delete.setDescription(PermissionDescription.ROLE_DELETE);

        Permission paginate_roles_get = new Permission();
        paginate_roles_get.setTag(PermissionName.PAGINATE_ROLES_GET);
        paginate_roles_get.setDescription(PermissionDescription.PAGINATE_ROLES_GET);

        Permission organization_create = new Permission();
        organization_create.setTag(PermissionName.ORGANIZATION_CREATE);
        organization_create.setDescription(PermissionDescription.ORGANIZATION_CREATE);

        Permission organization_update = new Permission();
        organization_update.setTag(PermissionName.ORGANIZATION_UPDATE);
        organization_update.setDescription(PermissionDescription.ORGANIZATION_UPDATE);

        Permission organization_delete = new Permission();
        organization_delete.setTag(PermissionName.ORGANIZATION_DELETE);
        organization_delete.setDescription(PermissionDescription.ORGANIZATION_DELETE);

        Permission paginate_organizations_get = new Permission();
        paginate_organizations_get.setTag(PermissionName.PAGINATE_ORGANIZATIONS_GET);
        paginate_organizations_get.setDescription(PermissionDescription.PAGINATE_ORGANIZATIONS_GET);

        Permission area_create = new Permission();
        area_create.setTag(PermissionName.AREA_CREATE);
        area_create.setDescription(PermissionDescription.AREA_CREATE);

        Permission area_update = new Permission();
        area_update.setTag(PermissionName.AREA_UPDATE);
        area_update.setDescription(PermissionDescription.AREA_UPDATE);

        Permission area_delete = new Permission();
        area_delete.setTag(PermissionName.AREA_DELETE);
        area_delete.setDescription(PermissionDescription.AREA_DELETE);

        Permission paginate_areas_get = new Permission();
        paginate_areas_get.setTag(PermissionName.PAGINATE_AREAS_GET);
        paginate_areas_get.setDescription(PermissionDescription.PAGINATE_AREAS_GET);

        Permission neighborhood_create = new Permission();
        neighborhood_create.setTag(PermissionName.NEIGHBORHOOD_CREATE);
        neighborhood_create.setDescription(PermissionDescription.NEIGHBORHOOD_CREATE);

        Permission neighborhood_update = new Permission();
        neighborhood_update.setTag(PermissionName.NEIGHBORHOOD_UPDATE);
        neighborhood_update.setDescription(PermissionDescription.NEIGHBORHOOD_UPDATE);

        Permission neighborhood_delete = new Permission();
        neighborhood_delete.setTag(PermissionName.NEIGHBORHOOD_DELETE);
        neighborhood_delete.setDescription(PermissionDescription.NEIGHBORHOOD_DELETE);

        Permission paginate_neighborhoods_get = new Permission();
        paginate_neighborhoods_get.setTag(PermissionName.PAGINATE_NEIGHBORHOODS_GET);
        paginate_neighborhoods_get.setDescription(PermissionDescription.PAGINATE_NEIGHBORHOODS_GET);

        Permission paginate_cities_get = new Permission();
        paginate_cities_get.setTag(PermissionName.PAGINATE_CITIES_GET);
        paginate_cities_get.setDescription(PermissionDescription.PAGINATE_CITIES_GET);

        Permission paginate_districts_get = new Permission();
        paginate_districts_get.setTag(PermissionName.PAGINATE_DISTRICTS_GET);
        paginate_districts_get.setDescription(PermissionDescription.PAGINATE_DISTRICTS_GET);

        Permission paginate_countries_get = new Permission();
        paginate_countries_get.setTag(PermissionName.PAGINATE_COUNTRIES_GET);
        paginate_countries_get.setDescription(PermissionDescription.PAGINATE_COUNTRIES_GET);

        Permission emission_source_create = new Permission();
        emission_source_create.setTag(PermissionName.EMISSION_SOURCE_CREATE);
        emission_source_create.setDescription(PermissionDescription.EMISSION_SOURCE_CREATE);

        Permission emission_source_update = new Permission();
        emission_source_update.setTag(PermissionName.EMISSION_SOURCE_UPDATE);
        emission_source_update.setDescription(PermissionDescription.EMISSION_SOURCE_UPDATE);

        Permission emission_source_delete = new Permission();
        emission_source_delete.setTag(PermissionName.EMISSION_SOURCE_DELETE);
        emission_source_delete.setDescription(PermissionDescription.EMISSION_SOURCE_DELETE);

        Permission paginate_emission_sources_get = new Permission();
        paginate_emission_sources_get.setTag(PermissionName.PAGINATE_EMISSION_SOURCES_GET);
        paginate_emission_sources_get.setDescription(PermissionDescription.PAGINATE_EMISSION_SOURCES_GET);

        Permission dataset_create = new Permission();
        dataset_create.setTag(PermissionName.DATASET_CREATE);
        dataset_create.setDescription(PermissionDescription.DATASET_CREATE);

        Permission dataset_update = new Permission();
        dataset_update.setTag(PermissionName.DATASET_UPDATE);
        dataset_update.setDescription(PermissionDescription.DATASET_UPDATE);

        Permission dataset_delete = new Permission();
        dataset_delete.setTag(PermissionName.DATASET_DELETE);
        dataset_delete.setDescription(PermissionDescription.DATASET_DELETE);

        Permission paginate_datasets_get = new Permission();
        paginate_datasets_get.setTag(PermissionName.PAGINATE_DATASETS_GET);
        paginate_datasets_get.setDescription(PermissionDescription.PAGINATE_DATASETS_GET);

        Permission answer_create = new Permission();
        answer_create.setTag(PermissionName.ANSWER_CREATE);
        answer_create.setDescription(PermissionDescription.ANSWER_CREATE);

        Permission answer_update = new Permission();
        answer_update.setTag(PermissionName.ANSWER_UPDATE);
        answer_update.setDescription(PermissionDescription.ANSWER_UPDATE);

        Permission answer_delete = new Permission();
        answer_delete.setTag(PermissionName.ANSWER_DELETE);
        answer_delete.setDescription(PermissionDescription.ANSWER_DELETE);

        Permission paginate_answers_get = new Permission();
        paginate_answers_get.setTag(PermissionName.PAGINATE_ANSWERS_GET);
        paginate_answers_get.setDescription(PermissionDescription.PAGINATE_ANSWERS_GET);

        Permission question_create = new Permission();
        question_create.setTag(PermissionName.QUESTION_CREATE);
        question_create.setDescription(PermissionDescription.QUESTION_CREATE);

        Permission question_update = new Permission();
        question_update.setTag(PermissionName.QUESTION_UPDATE);
        question_update.setDescription(PermissionDescription.QUESTION_UPDATE);

        Permission question_delete = new Permission();
        question_delete.setTag(PermissionName.QUESTION_DELETE);
        question_delete.setDescription(PermissionDescription.QUESTION_DELETE);

        Permission paginate_questions_get = new Permission();
        paginate_questions_get.setTag(PermissionName.PAGINATE_QUESTIONS_GET);
        paginate_questions_get.setDescription(PermissionDescription.PAGINATE_QUESTIONS_GET);

        Permission undelete_items = new Permission();
        undelete_items.setTag(PermissionName.UNDELETE_ITEMS);
        undelete_items.setDescription(PermissionDescription.UNDELETE_ITEMS);

        Permission published_survey_create = new Permission();
        published_survey_create.setTag(PermissionName.PUBLISHED_SURVEY_CREATE);
        published_survey_create.setDescription(PermissionDescription.PUBLISHED_SURVEY_CREATE);

        Permission surveys_get = new Permission();
        surveys_get.setTag(PermissionName.SURVEYS_GET);
        surveys_get.setDescription(PermissionDescription.SURVEYS_GET);

        Permission paginate_surveys_get = new Permission();
        paginate_surveys_get.setTag(PermissionName.PAGINATE_SURVEYS_GET);
        paginate_surveys_get.setDescription(PermissionDescription.PAGINATE_SURVEYS_GET);

        Permission survey_update = new Permission();
        survey_update.setTag(PermissionName.SURVEY_UPDATE);
        survey_update.setDescription(PermissionDescription.SURVEY_UPDATE);

        Permission survey_delete = new Permission();
        survey_delete.setTag(PermissionName.SURVEY_DELETE);
        survey_delete.setDescription(PermissionDescription.SURVEY_DELETE);

        Permission survey_add = new Permission();
        survey_add.setTag(PermissionName.SURVEY_ADD);
        survey_add.setDescription(PermissionDescription.SURVEY_ADD);

        Permission show_graphics = new Permission();
        show_graphics.setTag(PermissionName.SHOW_GRAPHICS);
        show_graphics.setDescription(PermissionDescription.SHOW_GRAPHICS);

        Permission settings_access = new Permission();
        settings_access.setTag(PermissionName.SETTINGS_ACCESS);
        settings_access.setDescription(PermissionDescription.SETTINGS_ACCESS);

        Permission data_center_create = new Permission();
        data_center_create.setTag(PermissionName.DATA_CENTER_CREATE);
        data_center_create.setDescription(PermissionDescription.DATA_CENTER_CREATE);

        Permission data_center_delete = new Permission();
        data_center_delete.setTag(PermissionName.DATA_CENTER_DELETE);
        data_center_delete.setDescription(PermissionDescription.DATA_CENTER_DELETE);

        Permission data_center_update = new Permission();
        data_center_update.setTag(PermissionName.DATA_CENTER_UPDATE);
        data_center_update.setDescription(PermissionDescription.DATA_CENTER_UPDATE);

        Permission data_center_read = new Permission();
        data_center_read.setTag(PermissionName.DATA_CENTER_READ);
        data_center_read.setDescription(PermissionDescription.DATA_CENTER_READ);

        Permission paginate_datacenters_get = new Permission();
        paginate_datacenters_get.setTag(PermissionName.PAGINATE_DATACENTERS_GET);
        paginate_datacenters_get.setDescription(PermissionDescription.PAGINATE_DATACENTERS_GET);

        permissionService.saveAll(List.of(
                show_graphics, activities_get, paginate_user_histories, activity_sub_units_get, sub_sectors_get,
                sectors_get, deleted_items, undelete_items, user_create, user_update, user_delete, paginate_users_get,
                role_create, role_update, role_delete, paginate_roles_get,
                organization_create, organization_update, organization_delete, paginate_organizations_get,
                area_create, area_update, area_delete, paginate_areas_get,
                neighborhood_create, neighborhood_update, neighborhood_delete, paginate_neighborhoods_get,
                paginate_districts_get,
                paginate_cities_get,
                paginate_countries_get,
                emission_source_create, emission_source_update, emission_source_delete, paginate_emission_sources_get,
                dataset_create, dataset_update, dataset_delete, paginate_datasets_get,
                answer_create, answer_delete, answer_update, paginate_answers_get,
                question_create, question_delete, question_update, paginate_questions_get,
                published_survey_create, surveys_get, paginate_surveys_get,
                survey_add, survey_delete, survey_update, settings_access, data_center_create, data_center_delete,
                data_center_update, data_center_read, paginate_datacenters_get));
    }

    public void createDefaultRole() {
        Role role = new Role();
        role.setTag("SUPER_ADMIN");
        role.setPermissions(permissionService.findAll());
        roleService.save(role);
    }

    void createCountry() {
        Country country = new Country();
        country.setCountryCode("TR");
        country.setName("Turkiye");
        countryRepo.save(country);

    }

    public void createCitiesFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/cities.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONArray jsonArray = new JSONArray(data);

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String cityName = jsonObject.getString("name");
            JSONArray cityCoordinates = jsonObject.getJSONArray("coordinates");

            City city = new City();
            city.setName(cityName);
            city.setCoordinates(cityCoordinates.toString());
            city.setCountry(countryService.findAll().get(0));
            cityRepo.save(city);
        }
    }

    public void createDistrictFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/districts.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONArray jsonArray = new JSONArray(data);

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String districtName = jsonObject.getString("name");
            String cityName = jsonObject.getString("city");
            JSONArray districtCoordinates = jsonObject.getJSONArray("coordinates");

            City city = cityRepo.findByName(cityName);
            District district = new District();
            district.setName(districtName);
            district.setCoordinates(districtCoordinates.toString());
            district.setCity(city);

            districtRepo.save(district);
        }
    }

    void createNeighborhoodsFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/neighbourhoods.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONArray jsonArray = new JSONArray(data);

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String cityName = jsonObject.getString("city");
            String districtName = jsonObject.getString("district");
            String neighborhoodName = jsonObject.getString("name");
            double minLong = jsonObject.getDouble("minLong");
            double minLat = jsonObject.getDouble("minLat");
            double maxLong = jsonObject.getDouble("maxLong");
            double maxLat = jsonObject.getDouble("maxLat");

            City city = cityRepo.findByName(cityName);
            if (city != null) {
                District district = city.getDistricts().stream()
                        .filter(d -> d.getName().equals(districtName))
                        .findFirst()
                        .orElse(null);

                if (district != null) {
                    Neighborhood neighborhood = new Neighborhood();
                    neighborhood.setName(neighborhoodName);
                    neighborhood.setDistrict(district);
                    neighborhood.setMinLong(minLong);
                    neighborhood.setMinLat(minLat);
                    neighborhood.setMaxLong(maxLong);
                    neighborhood.setMaxLat(maxLat);

                    neighborhoodRepo.save(neighborhood);
                }
            }
        }
    }

    void createSectorAndSubSectorFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/SectorsAndSubSectors.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Sectors");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Sector sector = new Sector();
            sector.setTag(jsonObject.getString("SectorName"));
            sector.setSectorNo(jsonObject.getInt("SectorNo"));
            sector.setDescription(jsonObject.getString("SectorName"));
            sectorService.save(sector);

            JSONArray subSectorsJson = jsonObject.getJSONArray("SubSectors");
            for (int j = 0; j < subSectorsJson.length(); j++) {
                JSONObject subSectorJson = subSectorsJson.getJSONObject(j);
                SubSector subSector = new SubSector();
                subSector.setSubSectorNo(subSectorJson.getInt("SubSectorNo"));
                subSector.setTag(subSectorJson.getString("Name"));
                subSector.setDescription(subSectorJson.getString("Name"));
                subSector.setSector(sector);
                subSectorService.save(subSector);
            }
        }
    }

    void createGpcReference() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/GpcReferenceNumbers.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("data");

        for (int i = 0; i < jsonArray.length(); i++) {
            GpcReference gpcReference = new GpcReference();
            gpcReference.setReferenceNumber(jsonArray.getString(i));
            gpcReference.setDescription(jsonArray.getString(i));
            gpcReferenceService.save(gpcReference);
        }
    }

    void createConsuptionUnit() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/ConsuptionUnits.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("units");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject unitObject = jsonArray.getJSONObject(i);

            String unitName = unitObject.getString("name");
            String unitDescription = unitObject.getString("description");

            ConsuptionUnit consuptionUnit = new ConsuptionUnit();
            consuptionUnit.setTag(unitName);
            consuptionUnit.setDescription(unitDescription);
            consuptionUnitService.save(consuptionUnit);
        }
    }

    void createEmissionSourceConvertUnit() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/EmissionSourceConvertUnit.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Data");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject obj = jsonArray.getJSONObject(i);
            List<EmissionSource> emissionSourceList = emissionSourceRepo.findByTag(obj.getString("EmissionSource"));
            ConsuptionUnit consuptionUnit = consuptionUnitRepo.findByTag(obj.getString("ConsuptionUnit")).get(0);

            for (EmissionSource emissionSource : emissionSourceList) {
                if (consuptionUnit != null) {
                    emissionSource.setConvertUnitCheck(true);
                    EmissionSource updatedEmissionSource = emissionSourceService.update(emissionSource);
                    EmissionSourceConvertUnit unit = new EmissionSourceConvertUnit();
                    unit.setEmissionSource(updatedEmissionSource);
                    unit.setUnit(consuptionUnit);
                    unit.setValue(obj.getDouble("Amount"));
                    emissionSourceConvertUnitService.save(unit);
                }
            }
        }
    }

    void createEmissionScope() {
        for (int i = 1; i < 4; i++) {
            EmissionScope emissionScope = new EmissionScope();
            emissionScope.setTag("Kapsam-" + i);
            emissionScope.setDescription("Kapsam-" + i);
            emissionScopeService.save(emissionScope);
        }
    }

    void createActivitySubUnit() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/ActivitySubUnits.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        List<String> tags = Arrays.asList("Konutlar", "Ticari ve Kurumsal Binalar", "İmalat Sanayi ve İnşaat Yapı",
                "Tarım, Ormancılık, Balıkçılık Faaliyetleri ve Balık Çiftlikleri",
                "Kömür Madenciliği, İşlenmesi, Depolanması ve Taşınmasından Kaynaklanan Kaçak Emisyonlar",
                "Karayolu Taşımacılığı", "Havayolu Taşımacılığı", "Demiryolu Taşımacılığı", "Arazi Taşımacılığı",
                "Denizyolu Taşımacılığı");

        for (String tag : tags) {
            JSONArray jsonArray = fullJson.getJSONArray(tag);
            SubSector subSector = subSectorRepo.findByTag(tag);
            for (int i = 0; i < jsonArray.length(); i++) {
                ActivitySubUnit activitySubUnit = new ActivitySubUnit();
                activitySubUnit.setTag(jsonArray.getString(i));
                activitySubUnit.setDescription(jsonArray.getString(i));
                activitySubUnit.setSubSector(subSector);
                activitySubUnitService.save(activitySubUnit);
            }
        }
    }

    void createEmissionSourceFromJson(String filePath, String[] subSectorTags) throws IOException {
        InputStream is = getClass().getResourceAsStream("/" + filePath);
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Data");

        String[] co2Tags = { "CO2", "CO2_1", "CO2_2", "CO2_3", "CO2_4" };
        String[] ch4Tags = { "CH4 (CO2e)", "CH4 (CO2e)_1", "CH4 (CO2e)_2", "CH4 (CO2e)_3", "CH4 (CO2e)_4" };
        String[] n20Tags = { "N20 (CO2e)", "N20 (CO2e)_1", "N20 (CO2e)_2", "N20 (CO2e)_3", "N20 (CO2e)_4" };

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String tag = jsonObject.getString("Emisyon Kaynağı");
            String scope = jsonObject.optString("scope");

            for (int j = 0; j < subSectorTags.length; j++) {
                EmissionSource emissionSource = new EmissionSource();
                emissionSource.setTag(tag);
                emissionSource.setEmissionScope(scope);
                emissionSource.setDescription(tag);
                emissionSource.setCo2(jsonObject.getDouble(co2Tags[j]));
                emissionSource.setCh4(jsonObject.getDouble(ch4Tags[j]));
                emissionSource.setN2o(jsonObject.getDouble(n20Tags[j]));
                emissionSource.setSubSector(subSectorRepo.findByTag(subSectorTags[j]));
                EmissionSource savedEmissionSource = emissionSourceService.save(emissionSource);

                EmissionSourceConvertUnit tjConvertUnit = new EmissionSourceConvertUnit();
                tjConvertUnit.setEmissionSource(savedEmissionSource);
                tjConvertUnit.setValue(1.0);
                tjConvertUnit.setUnit(consuptionUnitRepo.findByTag("TJ").get(0));
                EmissionSourceConvertUnit savedTjConvertUnit = emissionSourceConvertUnitService.save(tjConvertUnit);
            }
        }
    }

    void createWasteEmissionSourceFromJson(String filePath) throws IOException {
        InputStream is = getClass().getResourceAsStream("/" + filePath);
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Data");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            WasteEmissionSourceSupplement wasteEmissionSourceSupplement = new WasteEmissionSourceSupplement();
            wasteEmissionSourceSupplement.setDryWeightCH4(jsonObject.optDouble("dryWeightCH4", 0.0));
            wasteEmissionSourceSupplement.setWetWeightCH4(jsonObject.optDouble("wetWeightCH4", 0.0));
            wasteEmissionSourceSupplement.setDampWeightCH4(jsonObject.optDouble("dampWeightCH4", 0.0));
            wasteEmissionSourceSupplement.setDryWeightN2O(jsonObject.optDouble("dryWeightN2O", 0.0));
            wasteEmissionSourceSupplement.setWetWeightN2O(jsonObject.optDouble("wetWeightN2O", 0.0));
            WasteEmissionSourceSupplement savedWasteEmissionSourceSupplement = wasteEmissionSourceSupplementService
                    .save(wasteEmissionSourceSupplement);

            String tag = jsonObject.getString("Emisyon Kaynağı");
            EmissionSource emissionSource = new EmissionSource();
            emissionSource.setTag(tag);
            emissionSource.setDescription(tag);
            emissionSource.setCo2(0.0);
            emissionSource.setCh4(0.0);
            emissionSource.setN2o(0.0);
            emissionSource.setConvertUnitCheck(true);
            if (i < 2) {
                emissionSource.setSubSector(subSectorRepo.findByTag("Atıkların Biyolojik Arıtılması"));
            } else if (i < 10) {
                emissionSource.setSubSector(subSectorRepo.findByTag("Atık Su Arıtma ve Deşarjı"));
            } else if (i < 14) {
                emissionSource.setSubSector(subSectorRepo.findByTag("Yakma ve Açık Yanma"));
            }
            emissionSource.setWasteEmissionSourceSupplement(savedWasteEmissionSourceSupplement);
            emissionSourceService.save(emissionSource);
        }
    }

    void createSolidWasteTypeFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/SolidWasteTypes.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Data");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String typeName = jsonObject.getString("TypeName");
            double formulaCoefficient = jsonObject.getDouble("FormulaCoefficient");

            SolidWasteType solidWasteType = new SolidWasteType();
            solidWasteType.setTypeName(typeName);
            solidWasteType.setFormulaCoefficient(formulaCoefficient);
            solidWasteTypeService.save(solidWasteType);
        }
    }

    void createMcfTypeFromJson() throws IOException {
        InputStream is = getClass().getResourceAsStream("/XDataSetModuleFiles/MCFType.json");
        String data = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        JSONObject fullJson = new JSONObject(data);
        JSONArray jsonArray = fullJson.getJSONArray("Data");

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            String typeName = jsonObject.getString("TypeName");
            double value = jsonObject.getDouble("Value");

            McfType mcfType = new McfType();
            mcfType.setTypeName(typeName);
            mcfType.setValue(value);
            mcfTypeService.save(mcfType);
        }
    }

    void createDefaultMailInfo() {
        MailInfo mailInfo = new MailInfo();
        mailInfo.setHostName(mailHostname);
        mailInfo.setSmtpPort(mailSmtpPort);
        mailInfo.setEmailAddress(mailAddress);
        mailInfo.setEmailPassword(mailPassword);
        mailInfo.setMainMail(true);
        mailInfoService.save(mailInfo);
    }

    public void ensureMissingPermissions() {
        // Check if paginate_datacenters_get permission exists
        Optional<Permission> datacenterPermission = permissionService.findByTag("paginate_datacenters_get");
        if (!datacenterPermission.isPresent()) {
            // Create the missing permission
            Permission paginate_datacenters_get = new Permission();
            paginate_datacenters_get.setTag(PermissionName.PAGINATE_DATACENTERS_GET);
            paginate_datacenters_get.setDescription(PermissionDescription.PAGINATE_DATACENTERS_GET);
            permissionService.save(paginate_datacenters_get);
        }

        // Ensure SUPER_ADMIN has all permissions
        Optional<Role> superAdminRole = roleRepo.findByTag("SUPER_ADMIN");
        if (superAdminRole.isPresent()) {
            Role role = superAdminRole.get();
            List<Permission> allPermissions = permissionService.findAll();
            role.setPermissions(allPermissions);
            roleService.save(role);
        }
    }

    @Override
    public void run(String... args) throws Exception {
        if (mailInfoService.findAll().isEmpty()) {
            createDefaultMailInfo();
        }
        if (consuptionUnitService.findAll().isEmpty()) {
            createConsuptionUnit();
        }
        if (gpcReferenceService.findAll().isEmpty()) {
            createGpcReference();
        }
        if (emissionScopeService.findAll().isEmpty()) {
            createEmissionScope();
        }
        if (sectorService.findAll().isEmpty()) {
            createSectorAndSubSectorFromJson();
        }
        if (activitySubUnitService.findAll().isEmpty()) {
            createActivitySubUnit();
        }
        if (emissionSourceService.findAll().isEmpty()) {
            createEmissionSourceFromJson("XDataSetModuleFiles/EmissionSourceYenilenebilirEnerjiEF.json",
                    new String[] { "Güneş Enerji Santrali", "Rüzgar Enerji Santrali", "Hidroelektrik Enerji Santrali",
                            "Biyokütle Enerji Santrali", "Jeotermal Enerji Santrali" });
            createEmissionSourceFromJson("XDataSetModuleFiles/EmissionSourceSabitEnerjiEF.json",
                    new String[] { "Enerji Endüstrileri", "İmalat Sanayi ve İnşaat Yapı", "Ticari ve Kurumsal Binalar",
                            "Konutlar", "Tarım, Ormancılık, Balıkçılık Faaliyetleri ve Balık Çiftlikleri" });
            createEmissionSourceFromJson("XDataSetModuleFiles/EmissionSourceUlasimEF.json",
                    new String[] { "Karayolu Taşımacılığı", "Denizyolu Taşımacılığı", "Demiryolu Taşımacılığı",
                            "Arazi Taşımacılığı", "Havayolu Taşımacılığı" });
            createWasteEmissionSourceFromJson("XDataSetModuleFiles/EmissionSourceAtikEF.json");
            createEmissionSourceConvertUnit();
        }
        if (solidWasteTypeService.findAll().isEmpty()) {
            createSolidWasteTypeFromJson();
        }
        if (mcfTypeService.findAll().isEmpty()) {
            createMcfTypeFromJson();
        }
        if (permissionService.findAll().isEmpty()) {
            createDefaultPermission();
        }
        if (roleService.findAll().isEmpty()) {
            createDefaultRole();
        }
        // Ensure all permissions are created and assigned to SUPER_ADMIN
        ensureMissingPermissions();
        if (organizationService.findAll().isEmpty()) {
            createDefaultOrganization();
        }
        if (userService.findAll().isEmpty()) {
            createDefaultUser();
        }
        if (countryService.findAll().isEmpty()) {
            createCountry();
        }
        if (cityService.findAll().isEmpty()) {
            createCitiesFromJson();
            createDefaultArea();
        }
        if (districtService.findAll().isEmpty()) {
            createDistrictFromJson();
        }
        if (neighborhoodService.findAll().isEmpty()) {
            createNeighborhoodsFromJson();
        }
    }

    void createDefaultArea() {
        // Check if default area already exists
        List<Area> existingAreas = areaService.findAll();
        boolean defaultAreaExists = existingAreas.stream()
                .anyMatch(area -> "Turkiye".equals(area.getTag()) && area.isDefaultArea());

        if (!defaultAreaExists) {
            Area defaultArea = new Area();
            defaultArea.setTag("Turkiye");
            defaultArea.setDefaultArea(true);
            defaultArea.setDeleted(false);

            // Get all cities to add to the default area
            List<City> allCities = cityService.findAll();
            defaultArea.setCities(allCities);

            // Get the Turkey country to add to the default area
            List<Country> countries = countryService.findAll();
            if (!countries.isEmpty()) {
                defaultArea.setCountries(countries);
            }

            areaService.save(defaultArea);
        }
    }
}