//
// Created by cfif on 03.06.2024.
//
#include "SensorSPI.h"
#include "SystemDelayInterface.h"

static void setSensorTypeAdr(tSensorSPI *env, tConABC *connABC, uint8_t adr) {

    switch (adr) {
        case 0: {
            GpioPinSet(&connABC->A, false);
            GpioPinSet(&connABC->B, false);
            GpioPinSet(&connABC->C, false);
            break;
        }
        case 1: {
            GpioPinSet(&connABC->A, true);
            GpioPinSet(&connABC->B, false);
            GpioPinSet(&connABC->C, false);
            break;
        }
        case 2: {
            GpioPinSet(&connABC->A, false);
            GpioPinSet(&connABC->B, true);
            GpioPinSet(&connABC->C, false);
            break;
        }
        case 3: {
            GpioPinSet(&connABC->A, true);
            GpioPinSet(&connABC->B, true);
            GpioPinSet(&connABC->C, false);
            break;
        }
        case 4: {
            GpioPinSet(&connABC->A, false);
            GpioPinSet(&connABC->B, false);
            GpioPinSet(&connABC->C, true);
            break;
        }
        case 5: {
            GpioPinSet(&connABC->A, true);
            GpioPinSet(&connABC->B, false);
            GpioPinSet(&connABC->C, true);
            break;
        }
        case 6: {
            GpioPinSet(&connABC->A, false);
            GpioPinSet(&connABC->B, true);
            GpioPinSet(&connABC->C, true);
            break;
        }
        case 7: {
            GpioPinSet(&connABC->A, true);
            GpioPinSet(&connABC->B, true);
            GpioPinSet(&connABC->C, true);
            break;
        }
    }
}

#define DelayCn 1000

static void Delay(uint32_t count) {
    for (uint32_t i = 0; i < count; ++i) {
        __asm__ volatile("nop");
    }
}


bool setSpiSensor(tSensorSPI *env, tSensorType sensorType, tSensorAdr sensorAdr, uint16_t data) {

    switch (sensorType) {

        case SENSOR_TYPE_A: {

            bool result = false;


            if (sensorAdr >= SENSOR_ADR_9) {
                setSensorTypeAdr(env, &env->conns->COON_A.Con, sensorAdr - SENSOR_ADR_9);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_A.En1, true);
                GpioPinSet(&env->conns->COON_A.En2, false); // CS En2
            } else {
                setSensorTypeAdr(env, &env->conns->COON_A.Con, sensorAdr);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_A.En1, false); // CS En1
                GpioPinSet(&env->conns->COON_A.En2, true);
            }

            Delay(DelayCn);
            result = SpiPortTransmit(&env->spiPorts->Spi1_IO, &data, 1000);
            Delay(DelayCn);

            GpioPinSet(&env->conns->COON_A.En1, true);
            GpioPinSet(&env->conns->COON_A.En2, true);

            Delay(DelayCn);
            return result;
        }


        case SENSOR_TYPE_B: {
            bool result = false;

            // Эти управляются мультиплексором SENSOR_TYPE_A
            if ((sensorAdr == SENSOR_ADR_9) || (sensorAdr == SENSOR_ADR_10)) {

                if (sensorAdr == SENSOR_ADR_9) {
                    setSensorTypeAdr(env, &env->conns->COON_A.Con, SENSOR_ADR_7);
                }

                if (sensorAdr == SENSOR_ADR_10) {
                    setSensorTypeAdr(env, &env->conns->COON_A.Con, SENSOR_ADR_8);
                }

                GpioPinSet(&env->conns->COON_A.En1, true);
                GpioPinSet(&env->conns->COON_A.En2, false); // CS En2

                Delay(DelayCn);
                // Только тут SPI2
                result = SpiPortTransmit(&env->spiPorts->Spi2_IO, &data, 1000);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_A.En1, true);
                GpioPinSet(&env->conns->COON_A.En2, true);

                Delay(DelayCn);
            } else {


                setSensorTypeAdr(env, &env->conns->COON_B.Con, sensorAdr);

                Delay(DelayCn);
                result = SpiPortTransmit(&env->spiPorts->Spi2_IO, &data, 1000);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_B.En1, true);
            }

            Delay(DelayCn);
            return result;
        }


        case SENSOR_TYPE_E: {

            if (sensorAdr >= SENSOR_ADR_9) {
                setSensorTypeAdr(env, &env->conns->COON_E.Con, sensorAdr - SENSOR_ADR_9);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_E.En1, true);
                GpioPinSet(&env->conns->COON_E.En2, false); // CS En2
            } else {
                setSensorTypeAdr(env, &env->conns->COON_E.Con, sensorAdr);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_E.En1, false); // CS En1
                GpioPinSet(&env->conns->COON_E.En2, true);
            }

            Delay(DelayCn);
            bool result = SpiPortTransmit(&env->spiPorts->Spi3_IO, &data, 1000);
            Delay(DelayCn);

            GpioPinSet(&env->conns->COON_E.En1, true);
            GpioPinSet(&env->conns->COON_E.En2, true);

            Delay(DelayCn);
            return result;
        }


        case SENSOR_TYPE_D: {
            bool result = false;

            // Эти управляются мультиплексором SENSOR_TYPE_E
            if ((sensorAdr == SENSOR_ADR_9) || (sensorAdr == SENSOR_ADR_10)) {

                if (sensorAdr == SENSOR_ADR_9) {
                    setSensorTypeAdr(env, &env->conns->COON_E.Con, SENSOR_ADR_5);
                }

                if (sensorAdr == SENSOR_ADR_10) {
                    setSensorTypeAdr(env, &env->conns->COON_E.Con, SENSOR_ADR_6);
                }

                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_E.En1, true);
                GpioPinSet(&env->conns->COON_E.En2, false); // CS En2

                Delay(DelayCn);
                result = SpiPortTransmit(&env->spiPorts->Spi3_IO, &data, 1000);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_E.En1, true);
                GpioPinSet(&env->conns->COON_E.En2, true);

            } else {

                GpioPinSet(&env->conns->COON_D.En1, false); // CS En1
                Delay(DelayCn);

                setSensorTypeAdr(env, &env->conns->COON_D.Con, sensorAdr);

                Delay(DelayCn);
                result = SpiPortTransmit(&env->spiPorts->Spi3_IO, &data, 1000);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_D.En1, true);
            }

            Delay(DelayCn);
            return result;
        }


        case SENSOR_TYPE_F: {

            if (sensorAdr >= SENSOR_ADR_17) {
                setSensorTypeAdr(env, &env->conns->COON_F.Con, sensorAdr - SENSOR_ADR_17);
                Delay(DelayCn);

                GpioPinSet(&env->conns->COON_F.En1, true);
                GpioPinSet(&env->conns->COON_F.En2, true);
                GpioPinSet(&env->conns->COON_F.En3, false); // CS En3
            } else {

                if (sensorAdr >= SENSOR_ADR_9) {
                    setSensorTypeAdr(env, &env->conns->COON_F.Con, sensorAdr - SENSOR_ADR_9);
                    Delay(DelayCn);

                    GpioPinSet(&env->conns->COON_F.En1, true);
                    GpioPinSet(&env->conns->COON_F.En2, false); // CS En2
                    GpioPinSet(&env->conns->COON_F.En3, true);
                } else {
                    setSensorTypeAdr(env, &env->conns->COON_F.Con, sensorAdr);
                    Delay(DelayCn);

                    GpioPinSet(&env->conns->COON_F.En1, false); // CS En1
                    GpioPinSet(&env->conns->COON_F.En2, true);
                    GpioPinSet(&env->conns->COON_F.En3, true);
                }

            }

            Delay(DelayCn);
            bool result = SpiPortTransmit(&env->spiPorts->Spi4_IO, &data, 1000);
            Delay(DelayCn);

            GpioPinSet(&env->conns->COON_F.En1, true);
            GpioPinSet(&env->conns->COON_F.En2, true);
            GpioPinSet(&env->conns->COON_F.En3, true);


            Delay(DelayCn);
            return result;
        }


        case SENSOR_TYPE_C: {

            GpioPinSet(&env->conns->COON_C.En1, false); // CS En1

            setSensorTypeAdr(env, &env->conns->COON_C.Con, sensorAdr);

            Delay(DelayCn);
            bool result = SpiPortTransmit(&env->spiPorts->Spi2_IO, &data, 1000);
            Delay(DelayCn);

            GpioPinSet(&env->conns->COON_C.En1, true);

            Delay(DelayCn);
            return result;
        }

    }

    return false;
}

void SensorSpi_Init(tSensorSPI *env, tSpiPorts *spiPorts, tConns *conns) {
    env->spiPorts = spiPorts;
    env->conns = conns;
}