package com.intelligt.modbus.jlibmodbus.msg.base.mei;

import com.intelligt.modbus.jlibmodbus.Modbus;
import com.intelligt.modbus.jlibmodbus.data.DataHolder;
import com.intelligt.modbus.jlibmodbus.data.mei.ReadDeviceIdentificationInterface;
import com.intelligt.modbus.jlibmodbus.data.mei.ReadDeviceIdentificationInterface.DataObject;
import com.intelligt.modbus.jlibmodbus.exception.ModbusNumberException;
import com.intelligt.modbus.jlibmodbus.net.stream.base.ModbusInputStream;
import com.intelligt.modbus.jlibmodbus.net.stream.base.ModbusOutputStream;
import com.intelligt.modbus.jlibmodbus.utils.MEITypeCode;

import java.io.IOException;
import java.util.Arrays;

/*
 * Copyright (C) 2016 "Invertor" Factory", JSC
 * [http://www.sbp-invertor.ru]
 *
 * This file is part of JLibModbus.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Authors: Vladislav Y. Kochedykov, software engineer.
 * email: vladislav.kochedykov@gmail.com
 */
public class MEIReadDeviceIdentification implements ModbusEncapsulatedInterface {

    public static final int SIZE_OF_HEADER = 8;
    private int objectId = 0;
    private ReadDeviceIdentificationCode readDeviceIdCode = ReadDeviceIdentificationCode.BASIC_STREAM_ACCESS;
    private ConformityLevel conformityLevel = ConformityLevel.BASIC_STREAM_ONLY;
    private boolean moreFollows = false;
    private int nextObjectId = 0;
    private int numberOfObjects = 0;
    private DataObject[] objects = new DataObject[0];
    private int responseSize = 0;

    private int firstObjectIndex = 0;

    @Override
    public MEITypeCode getTypeCode() {
        return MEITypeCode.READ_DEVICE_IDENTIFICATION;
    }

    @Override
    public void writeRequest(ModbusOutputStream fifo) throws IOException {
        fifo.write(getReadDeviceIdCode().toInt());
        fifo.write(getObjectId());
    }

    @Override
    public void readRequest(ModbusInputStream fifo) throws IOException {
        setReadDeviceId(ReadDeviceIdentificationCode.get(fifo.read()));
        setObjectId(fifo.read());
    }

    @Override
    public int getRequestSize() {
        return 2;
    }

    @Override
    public void writeResponse(ModbusOutputStream fifo) throws IOException {
        fifo.write(getReadDeviceIdCode().toInt());
        fifo.write(getConformityLevel().toInt());
        fifo.write(isMoreFollows() ? 0xFF : 0x00);
        fifo.write(getNextObjectId());
        fifo.write(getNumberOfObjects());
        for (int i = getFirstObjectIndex(); i < getFirstObjectIndex() + getNumberOfObjects(); i++) {
            DataObject o = objects[i];
            fifo.write(o.getId());
            fifo.write(o.getValue().length);
            fifo.write(o.getValue());
        }
    }

    @Override
    public void readResponse(ModbusInputStream fifo) throws IOException, ModbusNumberException {
        setReadDeviceId(ReadDeviceIdentificationCode.get(fifo.read()));
        setConformityLevel(ConformityLevel.get(fifo.read()));
        setMoreFollows(fifo.read() == 0xff);
        setNextObjectId(fifo.read());
        setNumberOfObjects(fifo.read());
        if (getNumberOfObjects() > 0x7F) {
            throw new ModbusNumberException("Illegal number of data objects", getNumberOfObjects());
        }
        setObjects(new DataObject[getNumberOfObjects()]);
        int size = SIZE_OF_HEADER;
        for (int i = 0; i < getNumberOfObjects(); i++) {
            int id = fifo.read();
            int length = fifo.read();
            size += 2 + length;
            if (size > Modbus.MAX_PDU_LENGTH)
                throw new ModbusNumberException("Exceeded max pdu length", size);
            byte[] value = new byte[length];
            int read;
            if ((read = fifo.read(value)) != length)
                Modbus.log().warning(length + " bytes expected, but " + read + " received.");
            objects[i] = new DataObject(id, value);
        }
        setResponseSize(size);
    }

    @Override
    public int getResponseSize() {
        return responseSize;
    }

    public void setResponseSize(int responseSize) {
        this.responseSize = responseSize;
    }

    @Override
    public void process(DataHolder dataHolder) {
        ReadDeviceIdentificationInterface deviceId = dataHolder.getReadDeviceIdentificationInterface();
        if (deviceId.getExtended().length != 0) {
            setConformityLevel(ConformityLevel.EXTENDED_STREAM_AND_INDIVIDUAL);
        } else if (deviceId.getRegular().length != 0) {
            setConformityLevel(ConformityLevel.REGULAR_STREAM_AND_INDIVIDUAL);
        } else {
            setConformityLevel(ConformityLevel.BASIC_STREAM_AND_INDIVIDUAL);
        }
        switch (getReadDeviceIdCode()) {
            case BASIC_STREAM_ACCESS:
                setObjects(deviceId.getBasic());
                break;
            case REGULAR_STREAM_ACCESS:
                setObjects(deviceId.getRegular());
                break;
            case EXTENDED_STREAM_ACCESS:
                setObjects(deviceId.getExtended());
                break;
            case ONE_SPECIFIC_INDIVIDUAL_ACCESS:
            default:
                setObjects(new DataObject[]{deviceId.getValue(getObjectId())});
        }
        int size = SIZE_OF_HEADER;
        int number_of_objects = 0;

        if (getObjectId() != 0) {
            for (int i = 0; i < objects.length && getFirstObjectIndex() == 0; i++) {
                if (objects[i].getId() == getObjectId()) {
                    setFirstObjectIndex(i);
                }
            }
        }

        for (int i = getFirstObjectIndex(); i < objects.length; i++) {
            size += objects[i].getValue().length + 2;//object id + object length = 2
            if (size >= Modbus.MAX_PDU_LENGTH) {
                break;
            }
            number_of_objects++;
        }
        setResponseSize(size);
        if ((objects.length - getFirstObjectIndex()) > number_of_objects) {
            setNextObjectId(number_of_objects + 1);
        } else {
            setMoreFollows(false);
        }
        setNumberOfObjects(number_of_objects);
    }

    public int getNumberOfObjects() {
        return numberOfObjects;
    }

    public void setNumberOfObjects(int numberOfObjects) {
        this.numberOfObjects = numberOfObjects;
    }

    public int getObjectId() {
        return objectId;
    }

    public void setObjectId(int objectId) {
        this.objectId = objectId;
    }

    public ReadDeviceIdentificationCode getReadDeviceIdCode() {
        return readDeviceIdCode;
    }

    public void setReadDeviceId(ReadDeviceIdentificationCode readDeviceIdCode) {
        this.readDeviceIdCode = readDeviceIdCode;
    }

    public ConformityLevel getConformityLevel() {
        return conformityLevel;
    }

    public void setConformityLevel(ConformityLevel conformityLevel) {
        this.conformityLevel = conformityLevel;
    }

    public boolean isMoreFollows() {
        return moreFollows;
    }

    public void setMoreFollows(boolean moreFollows) {
        this.moreFollows = moreFollows;
    }

    public int getNextObjectId() {
        return nextObjectId;
    }

    public void setNextObjectId(int nextObjectId) {
        this.nextObjectId = nextObjectId;
    }

    public DataObject[] getObjects() {
        return Arrays.copyOf(objects, objects.length);
    }

    public void setObjects(DataObject[] objects) {
        this.objects = Arrays.copyOf(objects, objects.length);
    }

    public int getFirstObjectIndex() {
        return firstObjectIndex;
    }

    public void setFirstObjectIndex(int firstObjectIndex) {
        this.firstObjectIndex = firstObjectIndex;
    }
}