<?php

use App\Seeder as AppSeeder;
use Database\Seeders\AddIncapacidadPaymentMethodSeeder;
use Database\Seeders\DisableButtonEnableSection;
use Database\Seeders\TicketParametersSeeder;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class DatabaseSeeder extends Seeder
{

    private function getBatch()
    {
        $result = AppSeeder::select(DB::raw('MAX(batch) AS batch'))->first();
        $batch = 0;
        if ($result->batch)
            $batch = $result->batch;
        return $batch + 1;
    }

    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        /**
         * CARGA DE DATOS SEEDERS
         **/

        $batch = $this->getBatch();

        // DefaultSeeder
        if (!AppSeeder::where('seeder', 'DefaultSeeder')->first()) {
            $this->call(DefaultSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DefaultSeeder', 'batch' => $batch]);
        }

        // Seeder cobro de servicio
        if (!AppSeeder::where('seeder', 'ServiceChargesSeeder')->first()) {
            $this->call(ServiceChargesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServiceChargesSeeder', 'batch' => $batch]);
        }

        // Seeder reestructuración modulos
        if (!AppSeeder::where('seeder', 'ModulesRestructuringSeeder')->first()) {
            $this->call(ModulesRestructuringSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ModulesRestructuringSeeder', 'batch' => $batch]);
        }

        // Seeder calificación directorio de negocios
        if (!AppSeeder::where('seeder', 'AddModuleBusinessRatingSeeder')->first()) {
            $this->call(AddModuleBusinessRatingSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleBusinessRatingSeeder', 'batch' => $batch]);
        }

        // Seeder calificaciones por defecto
        if (!AppSeeder::where('seeder', 'BusinessRatingsDataSeeder')->first()) {
            $this->call(BusinessRatingsDataSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'BusinessRatingsDataSeeder', 'batch' => $batch]);
        }

        // Seeder diapositivas tutorial APP
        if (!AppSeeder::where('seeder', 'TutorialSlidesSeeder')->first()) {
            $this->call(TutorialSlidesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TutorialSlidesSeeder', 'batch' => $batch]);
        }

        // Seeder Modificar nombre item menu
        if (!AppSeeder::where('seeder', 'UpdateDataInTypeActionSeeder')->first()) {
            $this->call(UpdateDataInTypeActionSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateDataInTypeActionSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo tipo de configuración eventos boleteria
        if (!AppSeeder::where('seeder', 'CreateLabelTicketsForStageTypesSeeder')->first()) {
            $this->call(CreateLabelTicketsForStageTypesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateLabelTicketsForStageTypesSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo torneos de academias
        if (!AppSeeder::where('seeder', 'AcademyTournamentsSeeder')->first()) {
            $this->call(AcademyTournamentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyTournamentsSeeder', 'batch' => $batch]);
        }

        // Seeder fijar los iconos y botones principales del home para el APP
        if (!AppSeeder::where('seeder', 'AdjustBottonHomeIconsFromAppSectionSeeder')->first()) {
            $this->call(AdjustBottonHomeIconsFromAppSectionSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdjustBottonHomeIconsFromAppSectionSeeder', 'batch' => $batch]);
        }

        // Seeder dato de parametro por defecto ceder boleta
        if (!AppSeeder::where('seeder', 'TicketsParametersData')->first()) {
            $this->call(TicketsParametersData::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketsParametersData', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de lista de boletas cedidas
        if (!AppSeeder::where('seeder', 'AddModuleListTicketUserLogSeeder')->first()) {
            $this->call(AddModuleListTicketUserLogSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleListTicketUserLogSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de parametros
        if (!AppSeeder::where('seeder', 'AddModuleTicketsParametersSeeder')->first()) {
            $this->call(AddModuleTicketsParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleTicketsParametersSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo cuentas oficiales
        if (!AppSeeder::where('seeder', 'SocialNetworkAccountsSeeder')->first()) {
            $this->call(SocialNetworkAccountsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'SocialNetworkAccountsSeeder', 'batch' => $batch]);
        }

        // Seeder fecha de asistencia
        if (!AppSeeder::where('seeder', 'AcademyAttendanceDate')->first()) {
            $this->call(AcademyAttendanceDate::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyAttendanceDate', 'batch' => $batch]);
        }

        // Seeder de nuevos modulos en boleteria
        if (!AppSeeder::where('seeder', 'AddModulesTicketOffice')->first()) {
            $this->call(AddModulesTicketOffice::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModulesTicketOffice', 'batch' => $batch]);
        }

        // Seeder de nuevo modulos de creditos billetera
        if (!AppSeeder::where('seeder', 'AddModuleCreditCoinsSeeder')->first()) {
            $this->call(AddModuleCreditCoinsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleCreditCoinsSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de reporte redenciones
        if (!AppSeeder::where('seeder', 'ReportRedemptionsSeeder')->first()) {
            $this->call(ReportRedemptionsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ReportRedemptionsSeeder', 'batch' => $batch]);
        }

        // Seeder para fijar tipo de documento por defecto a los usuarios
        if (!AppSeeder::where('seeder', 'DocumentTypeDefaulSeeder')->first()) {
            $this->call(DocumentTypeDefaulSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentTypeDefaulSeeder', 'batch' => $batch]);
        }

        // Seeder dato de secciones home
        if (!AppSeeder::where('seeder', 'HomeSectionDataSeeder')->first()) {
            $this->call(HomeSectionDataSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'HomeSectionDataSeeder', 'batch' => $batch]);
        }

        // Seeder academia adultos
        if (!AppSeeder::where('seeder', 'AdultAcademySeeder')->first()) {
            $this->call(AdultAcademySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdultAcademySeeder', 'batch' => $batch]);
        }

        // Seeder administración modulo
        if (!AppSeeder::where('seeder', 'AdministrationLogsModule')->first()) {
            $this->call(AdministrationLogsModule::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdministrationLogsModule', 'batch' => $batch]);
        }

        // Seeder modulo métodos de pago
        if (!AppSeeder::where('seeder', 'PaymentMethodSeeder')->first()) {
            $this->call(PaymentMethodSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PaymentMethodSeeder', 'batch' => $batch]);
        }

        // Seeder reporte de academias
        if (!AppSeeder::where('seeder', 'AcademyReportSeeder')->first()) {
            $this->call(AcademyReportSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyReportSeeder', 'batch' => $batch]);
        }

        // Seeder para habilitar botón para adjuntar soportes de pago
        if (!AppSeeder::where('seeder', 'EnableAttachSupportButtonSeeder')->first()) {
            $this->call(EnableAttachSupportButtonSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'EnableAttachSupportButtonSeeder', 'batch' => $batch]);
        }

        //seder para renovacion de matricula
        if (!AppSeeder::where('seeder', 'AddModuleRegistrationRenewal')->first()) {
            $this->call(AddModuleRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleRegistrationRenewal', 'batch' => $batch]);
        }

        //seder para agregar la opcion de activar el boton de "renovar matricula"
        if (!AppSeeder::where('seeder', 'AcademyParameterAppComponentRegistrationRenewal')->first()) {
            $this->call(AcademyParameterAppComponentRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyParameterAppComponentRegistrationRenewal', 'batch' => $batch]);
        }

        //seeder para crear estado renovacion matricula
        if (!AppSeeder::where('seeder', 'AcademyStateRegistrationRenewal')->first()) {
            $this->call(AcademyStateRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyStateRegistrationRenewal', 'batch' => $batch]);
        }

        //seeder para generar un academy state duplicado para activar la revisión a partir de la renovación
        if (!AppSeeder::where('seeder', 'TagsPeaceAndSafetySeeder')->first()) {
            $this->call(TagsPeaceAndSafetySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TagsPeaceAndSafetySeeder', 'batch' => $batch]);
        }

        //seeder para generar academy state flow map
        if (!AppSeeder::where('seeder', 'AcademyStateFlowMapSeeder')->first()) {
            $this->call(AcademyStateFlowMapSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyStateFlowMapSeeder', 'batch' => $batch]);
        }

        // Seeder de estados de academia
        if (!AppSeeder::where('seeder', 'ErrorDocumentsSeeder')->first()) {
            $this->call(ErrorDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ErrorDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar logs de ticketing
        if (!AppSeeder::where('seeder', 'UpdateLogTicketingSeeder')->first()) {
            $this->call(UpdateLogTicketingSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateLogTicketingSeeder', 'batch' => $batch]);
        }

        // Seeder para módulo logs erp
        if (!AppSeeder::where('seeder', 'AddErpLogsModuleSeeder')->first()) {
            $this->call(AddErpLogsModuleSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddErpLogsModuleSeeder', 'batch' => $batch]);
        }

        // Seeder para documentos persona juridica
        if (!AppSeeder::where('seeder', 'AcademyDocumentsJuridicPersonSeeder')->first()) {
            $this->call(AcademyDocumentsJuridicPersonSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyDocumentsJuridicPersonSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar tipo de documento de all a NATURAL_PERSON
        if (!AppSeeder::where('seeder', 'updateTypeDocumentsSeeder')->first()) {
            $this->call(updateTypeDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'updateTypeDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder para módulo terminos y condiciones
        if (!AppSeeder::where('seeder', 'TermsConditionsSeeder')->first()) {
            $this->call(TermsConditionsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TermsConditionsSeeder', 'batch' => $batch]);
        }

        // Seeder para crear parametro de fecha de inscripciones en academia parametros
        if (!AppSeeder::where('seeder', 'CreateRegistrationStartDateAcademyParameters')->first()) {
            $this->call(CreateRegistrationStartDateAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateRegistrationStartDateAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para crear tipos de academia en parametros
        if (!AppSeeder::where('seeder', 'UniformTypeAcademyParameters')->first()) {
            $this->call(UniformTypeAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'UniformTypeAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para actualizar clase antigua de la pasarela wompi
        if (!AppSeeder::where('seeder', 'UpdateWompiGatewayClass')->first()) {
            $this->call(UpdateWompiGatewayClass::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateWompiGatewayClass', 'batch' => $batch]);
        }

        // Seeder para novedades academias
        if (!AppSeeder::where('seeder', 'AcademyNewsSeeder')->first()) {
            $this->call(AcademyNewsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyNewsSeeder', 'batch' => $batch]);
        }

        // Seeder para crear nuevo estado firmar documentos en academia
        if (!AppSeeder::where('seeder', 'SignAcademyDocuments')->first()) {
            $this->call(SignAcademyDocuments::class);
            AppSeeder::updateOrCreate(['seeder' => 'SignAcademyDocuments', 'batch' => $batch]);
        }

        // Seeder para crear modulo repositorio documental adultos
        if (!AppSeeder::where('seeder', 'ModuleRegistrationRenewalAdult')->first()) {
            $this->call(ModuleRegistrationRenewalAdult::class);
            AppSeeder::updateOrCreate(['seeder' => 'ModuleRegistrationRenewalAdult', 'batch' => $batch]);
        }

        // Seeder para parametros erp
        if (!AppSeeder::where('seeder', 'ERPParametersSeeder')->first()) {
            $this->call(ERPParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para hepldesk
        if (!AppSeeder::where('seeder', 'HelpdeskSeeder')->first()) {
            $this->call(HelpdeskSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'HelpdeskSeeder', 'batch' => $batch]);
        }

        // Seeder para crear botón tienda en academia
        if (!AppSeeder::where('seeder', 'StoreAcademy')->first()) {
            $this->call(StoreAcademy::class);
            AppSeeder::updateOrCreate(['seeder' => 'StoreAcademy', 'batch' => $batch]);
        }

        // Seeder para crear parametros de día de pago academia
        if (!AppSeeder::where('seeder', 'CreateMaximumPaymentDayMonthAcademyParameters')->first()) {
            $this->call(CreateMaximumPaymentDayMonthAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateMaximumPaymentDayMonthAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para crear nuevo tipo de reestricción tribuna
        if (!AppSeeder::where('seeder', 'CreateExclusiveTribuneStageType')->first()) {
            $this->call(CreateExclusiveTribuneStageType::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateExclusiveTribuneStageType', 'batch' => $batch]);
        }

        // Seeder añadir para añadir Certificado de salud APP
        if (!AppSeeder::where('seeder', 'AcademyDocumentsSeeder')->first()) {
            $this->call(AcademyDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder configuraciones/titulo PowerBI
        if (!AppSeeder::where('seeder', 'PowerBISeeder')->first()) {
            $this->call(PowerBISeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PowerBISeeder', 'batch' => $batch]);
        }

        // Seeder para la creacion de modulos contenido del club
        if (!AppSeeder::where('seeder', 'ClubContentSeeder')->first()) {
            $this->call(ClubContentSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ClubContentSeeder', 'batch' => $batch]);
        }

        // Seeder para la creacion de configuracion del club
        if (!AppSeeder::where('seeder', 'ClubParametersSeeder')->first()) {
            $this->call(ClubParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ClubParametersSeeder', 'batch' => $batch]);
        }

        //Publication dashboard seeder
        if (!AppSeeder::where('seeder', 'PublicationDashboardSeeder')->first()) {
            $this->call(PublicationDashboardSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PublicationDashboardSeeder', 'batch' => $batch]);
        }

        // Seeder data policy
        if (!AppSeeder::where('seeder', 'DataPolicySeeder')->first()) {
            $this->call(DataPolicySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DataPolicySeeder', 'batch' => $batch]);
        }

        // Seeder para añadir configuración en tickets/parameter
        if (!AppSeeder::where('seeder', 'addTicketConfigurationInParametersSeeder')->first()) {
            $this->call(AddTicketConfigurationInParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'addTicketConfigurationInParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir una app section y actualizar con dos meses en las fechas de parametros para club
        if (!AppSeeder::where('seeder', 'AppSectionAndUpdateVariableSeeder')->first()) {
            $this->call(AppSectionAndUpdateVariableSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AppSectionAndUpdateVariableSeeder', 'batch' => $batch]);
        }

        // Seeder para modificar Contenido del club
        if (!AppSeeder::where('seeder', 'DisableButtonEnableSection')->first()) {
            $this->call(DisableButtonEnableSection::class);
            AppSeeder::updateOrCreate(['seeder' => 'DisableButtonEnableSection', 'batch' => $batch]);
        }

        // Seeder para añadir Incapacidad a la tabla de payment_methods
        if (!AppSeeder::where('seeder', 'AddIncapacidadPaymentMethodSeeder')->first()) {
            $this->call(AddIncapacidadPaymentMethodSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddIncapacidadPaymentMethodSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir terminos y condiciones de ticket_parameters
        if (!AppSeeder::where('seeder', 'TicketParametersSeeder')->first()) {
            $this->call(TicketParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir módilo de membresias
        if (!AppSeeder::where('seeder', 'MembershipsSeeder')->first()) {
            $this->call(MembershipsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'MembershipsSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir modulo de experiencias
        if (!AppSeeder::where('seeder', 'ExperienceSeeder')->first()) {
            $this->call(ExperienceSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ExperienceSeeder', 'batch' => $batch]);
        }

        // Seeder para poblar la tabla de ciudades de servientrega
        if (!AppSeeder::where('seeder', 'ServientregaCitiesSeeder')->first()) {
            $this->call(ServientregaCitiesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServientregaCitiesSeeder', 'batch' => $batch]);
        }

        // Seeder para poblar la tabla divipola
        if (!AppSeeder::where('seeder', 'DivipolaTableSeeder')->first()) {
            $this->call(DivipolaTableSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DivipolaTableSeeder', 'batch' => $batch]);
        }

        // Seeder para fijar los precios de servicio de servientrega
        if (!AppSeeder::where('seeder', 'ServientregaServiceFixPrices')->first()) {
            $this->call(ServientregaServiceFixPrices::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServientregaServiceFixPrices', 'batch' => $batch]);
        }

        // Seeder para actualizar modulo de validacion de referencias
        if (!AppSeeder::where('seeder', 'AdjustModulePaymentsValidator')->first()) {
            $this->call(AdjustModulePaymentsValidator::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdjustModulePaymentsValidator', 'batch' => $batch]);
        }
    }
}