/*
 * Copyright (C) 2015, 2016 "IoT.bzh"
 * Author "Romain Forlot" <romain.forlot@iot.bzh>
 *
 * 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.
 */

#include <fnmatch.h>

#include "can-signals.hpp"

#include "../configuration.hpp"
#include "../utils/signals.hpp"
#include "can-decoder.hpp"
#include "../obd2/obd2-signals.hpp"
#include "../low-can-binding.hpp"

std::string can_signal_t::prefix_ = "messages";

can_signal_t::can_signal_t(can_message_definition_t& message, std::string generic_name, uint8_t bit_position, uint8_t bit_size,
			 float factor, float offset, float min_value, float max_value, frequency_clock_t frequency, bool send_same, bool force_send_changed,
			 std::vector<std::string> states, bool writable, SignalDecoder decoder, SignalEncoder encoder, bool received)
	: message_{message}, generic_name_{generic_name}, bit_position_{bit_position}, bit_size_{bit_size}, factor_{factor}, offset_{offset},
	min_value_{min_value}, max_value_{max_value}, frequency_{frequency}, send_same_{send_same}, force_send_changed_{force_send_changed}, states_{states},
	writable_{writable}, decoder_{decoder}, encoder_{encoder}, received_{received}, last_value_{(float)NULL}
{}

can_message_definition_t& can_signal_t::get_message()
{
	return message_;
}

const std::string& can_signal_t::get_generic_name() const
{
	return generic_name_;
}

const std::string can_signal_t::get_name() const
{
	return prefix_ + "." + generic_name_;
}

const std::string& can_signal_t::get_prefix() const
{
	return prefix_;
}

uint8_t can_signal_t::get_bit_position() const
{
	return bit_position_;
}

uint8_t can_signal_t::get_bit_size() const
{
	return bit_size_;
}

float can_signal_t::get_factor() const
{
	return factor_;
}

float can_signal_t::get_offset() const
{
	return offset_;
}

float can_signal_t::get_min_value() const
{
	return min_value_;
}	

float can_signal_t::get_max_value() const
{
	return max_value_;
}

frequency_clock_t& can_signal_t::get_frequency()
{
	return frequency_;
}

bool can_signal_t::get_send_same() const
{
	return send_same_;
}

bool can_signal_t::get_force_send_changed() const
{
	return force_send_changed_;
}

const std::vector<std::string>& can_signal_t::get_states() const
{
	return states_;
}

const std::string can_signal_t::get_states(float value) const
{
	if (value < states_.size())
		return states_[(int)value];
	return std::string("");
}

size_t can_signal_t::get_state_count() const
{
	return states_.size();
}

bool can_signal_t::get_writable() const
{
	return writable_;
}

SignalDecoder& can_signal_t::get_decoder()
{
	return decoder_;
}

SignalEncoder& can_signal_t::get_encoder()
{
	return encoder_;
}

bool can_signal_t::get_received() const
{
	return received_;
}
float can_signal_t::get_last_value() const
{
	return last_value_;
}

void can_signal_t::set_prefix(std::string val)
{
	prefix_ = val;
}

void can_signal_t::set_received(bool r)
{
	received_ = r;
}

void can_signal_t::set_last_value(float val)
{
	last_value_ = val;
}