package art.servers.colorsserver.M.protocol;

import art.library.model.devices.Device;
import art.library.model.devices.DeviceCommands;
import art.library.model.devices.colors.controller.M.M_ControllerStatusSubcontroller;
import art.library.model.devices.colors.controller.M.commands.M_ControllerCommandsSpecialDemand;
import art.library.model.devices.colors.controller.M.configuration.ALUVISA_Phase;
import art.library.model.devices.colors.controller.M.configuration.ALUVISA_Plan;
import art.servers.colorsserver.controller.ControllerRtacController;
import java.util.Calendar;
import java.util.List;

public class M_ProtocolConstructor 
{
    public static M_Message readTableMessage(int controllerCode, int tableCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_READ_TABLE_FULL);
        writer.write(tableCode);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message readTableMessagePartial(int controllerCode, int tableCode, boolean hasCRC, int blockNumber)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_READ_TABLE_PARTIAL);
//        writer.write(blockNumber);
        writer.write(tableCode);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message writeTableMessage(int controllerCode, List<Byte> lTableContent, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        int pointer = 1;
        for (;pointer<2; pointer++)
            writer.write(lTableContent.get(pointer).byteValue());

        writer.write(writer.M_WRITE_TABLE_FULL);

        for (;pointer<lTableContent.size()-1; pointer++)
        {
            int data = lTableContent.get(pointer).byteValue();
            if ((data < 0x80) && (data >= 0))
                writer.writeEOB(data);
            else
                writer.write(data);
        }

        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message startRecordingTablesMessage(int controllerCode, String communicationsPassword, String controllerNumber, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_START_RECORDING);
        if (communicationsPassword.length() < 12)
        {
            for (int i=0; i<(12-communicationsPassword.length()); i++)
                writer.write(0x30);
        }
        for (int i=0; i<communicationsPassword.length(); i++)
            writer.write((int)communicationsPassword.charAt(i));

        if (controllerNumber.length() < 6)
        {
            for (int i=0; i<(6-controllerNumber.length()); i++)
                writer.write(0x30);
        }
        for (int i=0; i<controllerNumber.length(); i++)
            writer.write((int)controllerNumber.charAt(i));
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message endRecordingTablesMessage(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_END_RECORDING);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message setBusDetectionsRealtime(int subcontrollerCode, boolean activate, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontrollerCode);
        if (activate == true)
            writer.write(writer.M_SET_REALTIME_BUS_DETECTIONS_ENABLE);
        else
            writer.write(writer.M_SET_REALTIME_BUS_DETECTIONS_DISABLE);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontrollerCode));
    }


    public static M_Message getBusDetectionsPeriod(int subcontrollerCode, Calendar calendarStart, Calendar calendarEnd, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontrollerCode);
        writer.write(writer.M_BUS_DETECTIONS_QUERY);

        // Start
        {
            writer.write(calendarStart.get(Calendar.DATE));
            writer.write(calendarStart.get(Calendar.MONTH) + 1);
            writer.write(calendarStart.get(Calendar.YEAR) - 2000);
            writer.write(calendarStart.get(Calendar.HOUR_OF_DAY));
            writer.write(calendarStart.get(Calendar.MINUTE));
        }

        // End
        {
            writer.write(calendarEnd.get(Calendar.DATE));
            writer.write(calendarEnd.get(Calendar.MONTH) + 1);
            writer.write(calendarEnd.get(Calendar.YEAR) - 2000);
            writer.write(calendarEnd.get(Calendar.HOUR_OF_DAY));
            writer.write(calendarEnd.get(Calendar.MINUTE));
        }

        writer.ETX(hasCRC);

        return(writer.createMessage(subcontrollerCode));
    }


    public static M_Message getCurrentPlan(int subcontrollerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontrollerCode);
        writer.write(writer.M_CURRENT_PLAN_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontrollerCode));
    }


    public static M_Message getAlarms(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_ALARMS_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getBlownLampsAlarms(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_BLOWN_LAMPS_ALARMS_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getDamagedGroupAlarms(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_DAMAGED_GROUP_ALARMS_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getIncompatibilityAlarms(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_INCOMPATIBILITY_ALARMS_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getCurrentTime(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_CURRENT_TIME_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getCurrentStatusGroups(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_CURRENT_STATUS_GROUPS_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getCurrentState(int subcontrollerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontrollerCode);
        writer.write(writer.M_CURRENT_SUBCONTROLLER_STATE_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontrollerCode));
    }


    public static M_Message getCurrentPresenceDetectors(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_CURRENT_PRESENCE_DETECTORS);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getCurrentCountingDetectors(int controllerCode)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.DET();

        return(writer.createMessage(controllerCode));
    }


    public static M_Message getCurrentCountingDetectorsDatetime(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();
        
        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_CURRENT_COUNTING_DETECTORS);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message setRecordablePlan(ALUVISA_Plan recordablePlan, int subcontroller, int transitionsToTimesTable, int minimumAndExtensionTimesTable, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontroller);
        writer.write(writer.M_SAVE_RECORDABLE_PLAN);
        writer.write(recordablePlan.structure);
        writer.write(transitionsToTimesTable);
        writer.write(minimumAndExtensionTimesTable);
        writer.write((recordablePlan.offset >> 7) & 0x7F);
        writer.write(recordablePlan.offset & 0x7F);
        writer.write(recordablePlan.controlMode);
        for (ALUVISA_Phase phase : recordablePlan.lPhase)
            writer.write(phase.maximumTime);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontroller));
    }


    public static M_Message getRecordablePlan(int subcontrollerNumber, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontrollerNumber);
        writer.write(writer.M_RECORDABLE_PLAN_QUERY);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontrollerNumber));
    }


    public static M_Message setPlan(int plan, long referenceTime, int subcontroller, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(referenceTime);

        if (referenceTime == 0)
        {
            writer.STX();
            writer.write(subcontroller);
            writer.write(writer.M_SELECT_PLAN);
            writer.write(plan);
            writer.write(0x00);
            writer.write(0x00);
            writer.write(0x00);
            writer.ETX(hasCRC);
        }
        else
        {
            writer.STX();
            writer.write(subcontroller);
            writer.write(writer.M_SELECT_PLAN);
            writer.write(plan);
            writer.write(calendar.get(Calendar.HOUR_OF_DAY));
            writer.write(calendar.get(Calendar.MINUTE));
            writer.write(calendar.get(Calendar.SECOND));
            writer.ETX(hasCRC);
        }

        return(writer.createMessage(subcontroller));
    }


    public static M_Message selectSpecialDemand(M_ControllerCommandsSpecialDemand specialDemand, int subcontroller, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontroller);
        writer.write(writer.M_SELECT_SPECIAL_DEMAND);
        writer.write(specialDemand.number);
        writer.write(specialDemand.time);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontroller));
    }


    public static M_Message cancelSpecialDemand(M_ControllerCommandsSpecialDemand specialDemand, int subcontroller, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontroller);
        writer.write(writer.M_CANCEL_SPECIAL_DEMAND);
        writer.write(specialDemand.number);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontroller));
    }


    public static M_Message setState(int subcontroller, int colorsMode, int planSelection, int adaptative, int adaptativeDetectors, 
            int coordinationMode, int centralizedMode, int manualControl, int controlComputerDirectGroups, 
            int operationMode, int sptpOperation, int emergency, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        int controlMode = 0x00;
        int coordination = 0x00;
        int operation = 0x00;

        // Control mode byte calculation
        if (planSelection == M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE)
        {
            controlMode = controlMode + 0x00;
        }
        else if (planSelection == M_ControllerStatusSubcontroller.PLANSELECTION_EXTERNAL_PLANS)
        {
            controlMode = controlMode + 0x01;
        }
        else if (planSelection == M_ControllerStatusSubcontroller.PLANSELECTION_ICF)
        {
            controlMode = controlMode + 0x02;
        }
        else if (planSelection == M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER)
        {
            controlMode = controlMode + 0x04;
        }

        if (adaptative == DeviceCommands.CONDITION_YES)
        {
            controlMode = controlMode + 0x08;
        }

        if (adaptativeDetectors == DeviceCommands.CONDITION_YES)
        {
            controlMode = controlMode + 0x10;
        }


        // Coordination byte calculation
        if (coordinationMode == M_ControllerStatusSubcontroller.COORDINATION_EXTERNAL)
        {
            coordination = coordination + 0x00;
        }
        else if (coordinationMode == M_ControllerStatusSubcontroller.COORDINATION_INTERNAL_CLOCK)
        {
            coordination = coordination + 0x01;
        }
        else if (coordinationMode == M_ControllerStatusSubcontroller.COORDINATION_COMPUTER)
        {
            coordination = coordination + 0x02;
        }

        if (centralizedMode == DeviceCommands.CONDITION_YES)
        {
            coordination = coordination + 0x04;
        }

        if (manualControl == DeviceCommands.CONDITION_YES)
        {
            coordination = coordination + 0x04;
        }

        if (controlComputerDirectGroups == DeviceCommands.CONDITION_YES)
        {
            coordination = coordination + 0x10;
        }


        // Operation byte calculation
        if (operationMode == M_ControllerStatusSubcontroller.OPERATIONMODE_FIXED)
        {
            operation = operation + 0x00;
        }
        else if (operationMode == M_ControllerStatusSubcontroller.OPERATIONMODE_SEMIACTUATED)
        {
            operation = operation + 0x01;
        }
        else if (operationMode == M_ControllerStatusSubcontroller.OPERATIONMODE_ACTUATED)
        {
            operation = operation + 0x02;
        }

        if (emergency == DeviceCommands.CONDITION_YES)
        {
            operation = operation + 0x04;
        }

        if (sptpOperation == M_ControllerStatusSubcontroller.SPTP_OPERATION_LOCAL)
        {
            operation = operation + 0x08;
        }
        else if (sptpOperation == M_ControllerStatusSubcontroller.SPTP_OPERATION_COORDINATED)
        {
            operation = operation + 0x10;
        }

        writer.STX();
        writer.write(subcontroller);
        writer.write(writer.M_SET_STATE);
        writer.write(colorsMode);
        writer.write(controlMode);
        writer.write(coordination);
        writer.write(operation);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontroller));
    }


    public static M_Message setDateTime(int controllerCode, long timestamp, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();
        // 02 80 D2 83 8B 97 9D 8E 83 92 03

        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(timestamp);
        int weekday = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        if (weekday == 0) weekday = 1;  // Sunday
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int minutes = calendar.get(Calendar.MINUTE);
        int seconds = calendar.get(Calendar.SECOND);
        int day = calendar.get(Calendar.DATE);
        int month = calendar.get(Calendar.MONTH) + 1;
        int year = calendar.get(Calendar.YEAR) - 2000;

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_SET_TIME);
        writer.write(weekday);
        writer.write(hour);
        writer.write(minutes);
        writer.write(seconds);
        writer.write(day);
        writer.write(month);
        writer.write(year);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message setDateTimeRTAC(ControllerRtacController controller, int controllerCode, long timestamp, int weekday, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();
        // 02 80 D2 83 8B 97 9D 8E 83 92 03

        controller.writeLog("\t" + controller.getController().getIdentifier() + " - 1.SETTIME: CurrentWeekday: " + weekday);

        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(timestamp);
        calendar.set(Calendar.YEAR, 2008);
//        int weekdayCalendar = calendar.get(Calendar.DAY_OF_WEEK);
        int weekdayCalendar = calendar.get(Calendar.DAY_OF_WEEK);
        int weekdayTimestamp = 0;

        switch (weekdayCalendar)
        {
            case Calendar.MONDAY:
            case Calendar.TUESDAY:
            case Calendar.WEDNESDAY:
            case Calendar.THURSDAY:
            case Calendar.FRIDAY:
            case Calendar.SATURDAY:
            {
                weekdayTimestamp = weekdayCalendar - 2;
            }
            break;

            case Calendar.SUNDAY:
            {
                weekdayTimestamp = 6;
            }
            break;
        }

        controller.writeLog("\t" + controller.getController().getIdentifier() + " - 2.SETTIME: Weekday: " + weekday + " - WeekdayCalendar: " + weekdayCalendar + " - WeekdayTimestamp: " + weekdayTimestamp + " - " + Device.getDate(timestamp));
        if (weekdayTimestamp != weekday)
        {
            long dif = getSumDays(weekday, weekdayTimestamp);
            long ts = calendar.getTimeInMillis() + ((long)(dif)*(24L*60*60L*1000L));
            calendar.setTimeInMillis(ts);
            controller.writeLog("\t" + controller.getController().getIdentifier() + " - 3.SETTIME: Weekday: " + weekday + " - WeekdayCalendar: " + weekdayCalendar + " - WeekdayTimestamp: " + weekdayTimestamp + " - DIF: " + dif + " - " + Device.getDate(ts));

            weekdayCalendar = calendar.get(Calendar.DAY_OF_WEEK);
            weekdayTimestamp = 0;
            switch (weekdayCalendar)
            {
                case Calendar.MONDAY:
                case Calendar.TUESDAY:
                case Calendar.WEDNESDAY:
                case Calendar.THURSDAY:
                case Calendar.FRIDAY:
                case Calendar.SATURDAY:
                {
                    weekdayTimestamp = weekdayCalendar - 2;
                }
                break;

                case Calendar.SUNDAY:
                {
                    weekdayTimestamp = 6;
                }
                break;
            }

            controller.writeLog("\t" + controller.getController().getIdentifier() + " - 4.SETTIME: Weekday: " + weekday + " - WeekdayCalendar: " + weekdayCalendar + " - WeekdayTimestamp: " + weekdayTimestamp + " - DIF: " + dif);
        }

        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int minutes = calendar.get(Calendar.MINUTE);
        int seconds = calendar.get(Calendar.SECOND);
        int day = calendar.get(Calendar.DATE);
        int month = calendar.get(Calendar.MONTH) + 1;
        int year = calendar.get(Calendar.YEAR) - 2000;
    
        controller.writeLog("\t" + controller.getController().getIdentifier() + " - 5.SETTIME: Weekday timestamp: " + weekdayTimestamp + " - " + Device.getDate(calendar.getTimeInMillis()));

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_SET_TIME);
        writer.write(weekdayTimestamp);
        writer.write(hour);
        writer.write(minutes);
        writer.write(seconds);
        writer.write(day);
        writer.write(month);
        writer.write(year);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message HTR()
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();
        writer.writeRaw(writer.HTR);
        return(writer.createMessage(0x00));
    }


    public static M_Message PRH()
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();
        writer.writeRaw(writer.PRH);
        return(writer.createMessage(0x00));
    }


    public static M_Message setRealtimeDetectors(int controllerCode, List<Integer> ldetectors, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_SET_REALTIME_DETECTORS);

        int pointer = 0;
        for (Integer detector : ldetectors)
        {
            writer.write(detector);
            pointer++;
        }

        if (ldetectors.size() > 0)
        {
            for (int i=pointer; i<4; i++)
                writer.write(ldetectors.get(0));
        }

        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message clearAlarms(int controllerCode, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);
        writer.write(writer.M_ERASE_ALARMS);
        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }


    public static M_Message phaseChanging(int subcontroller, int source, int destination, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(subcontroller);
        writer.write(writer.M_PHASE_CHANGING);
        writer.write(source);
        writer.write(destination);
        writer.write(0);
        writer.ETX(hasCRC);

        return(writer.createMessage(subcontroller));
    }
//
//
//    public static M_Message setDirectGroupOutput(int controllerCode, List<M_ControllerCommandsDirectGroupOutput> ldirectGroupOutput, boolean hasCRC)
//    {
//        M_ProtocolWriter writer = new M_ProtocolWriter();
//
//        writer.STX();
//        writer.write(controllerCode);
//        writer.write(writer.M_DIRECT_GROUP_OUTPUT);
//        for (M_ControllerCommandsDirectGroupOutput directGroupOutput : ldirectGroupOutput)
//        {
//            writer.write(directGroupOutput.group);
//            writer.write(directGroupOutput.color);
//        }
//        writer.ETX(hasCRC);
//
//        return(writer.createMessage(controllerCode));
//    }


    public static M_Message setGroupsRealtime(int controllerCode, int realtime, boolean hasCRC)
    {
        M_ProtocolWriter writer = new M_ProtocolWriter();

        writer.STX();
        writer.write(controllerCode);

        if (realtime == DeviceCommands.CONDITION_YES)
            writer.write(writer.M_GROUPS_REALTIME_ENABLE);
        else
            writer.write(writer.M_GROUPS_REALTIME_DISABLE);

        writer.ETX(hasCRC);

        return(writer.createMessage(controllerCode));
    }







    private static long getSumDays(int weekdayTimestamp, int weekday)
    {
        switch (weekdayTimestamp)
        {
            case 0:  // LUNES
            {
                switch (weekday)
                {
                    case 1: return(-1);
                    case 2: return(-2);
                    case 3: return(-3);
                    case 4: return(-4);
                    case 5: return(-5);
                    case 6: return(-6);
                }
            };
            break;
            case 1:  // MARTES
            {
                switch (weekday)
                {
                    case 0: return(1);
                    case 2: return(-1);
                    case 3: return(-2);
                    case 4: return(-3);
                    case 5: return(-4);
                    case 6: return(-5);
                }
            };
            break;
            case 2:  // MIERCOLES
            {
                switch (weekday)
                {
                    case 0: return(2);
                    case 1: return(1);
                    case 3: return(-1);
                    case 4: return(-2);
                    case 5: return(-3);
                    case 6: return(-4);
                }
            };
            break;
            case 3:  // JUEVES
            {
                switch (weekday)
                {
                    case 0: return(3);
                    case 1: return(2);
                    case 2: return(1);
                    case 4: return(-1);
                    case 5: return(-2);
                    case 6: return(-3);
                }
            };
            break;
            case 4:  // VIERNES
            {
                switch (weekday)
                {
                    case 0: return(4);
                    case 1: return(3);
                    case 2: return(2);
                    case 3: return(1);
                    case 5: return(-1);
                    case 6: return(-2);
                }
            };
            break;
            case 5:  // SABADO
            {
                switch (weekday)
                {
                    case 0: return(-2);
                    case 1: return(-3);
                    case 2: return(-4);
                    case 3: return(-5);
                    case 4: return(-6);
                    case 6: return(-1);
                }
            };
            break;
            case 6:  // DOMINGO
            {
                switch (weekday)
                {
                    case 0: return(-1);
                    case 1: return(-2);
                    case 2: return(-3);
                    case 3: return(-4);
                    case 4: return(-5);
                    case 5: return(-6);
                }
            };
            break;
        }
        return(weekday);
    }

}