using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.Serialization;
using TINK.Model.Bikes.Bike;
using TINK.Model.Bikes.Bike.BC;
using TINK.Model.State;

namespace TINK.Model.Bike.BC
{
    [DataContract]
    public class BikeInfoMutable : IBikeInfoMutable, INotifyPropertyChanged
    {
        /// <summary> Holds the bike. </summary>
        private readonly Bike m_oBike;

        /// <summary> Holds the state info of the bike. </summary>
        private readonly StateInfoMutable m_oStateInfo;

        /// <summary>
        /// Constructs a bike.
        /// </summary>
        /// <param name="id">Unique id of bike.</param>
        /// <param name="isDemo">True if device is demo device, false otherwise.</param>
        /// <param name="dateTimeProvider">Provider for current date time to calculate remainig time on demand for state of type reserved.</param>
        /// <param name="wheelType"></param>
        /// <param name="stationId">Name of station where bike is located, null if bike is on the road.</param>
        /// <param name="operatorUri">Holds the uri of the operator or null, in case of single operator setup.</param>
        /// <param name="tariffDescription">Hold tariff description of bike.</param>
        /// <param name="stateInfo">Bike state info.</param>
        protected BikeInfoMutable(
            string id,
            LockModel lockModel,
            bool isDemo = BikeInfo.DEFAULTVALUEISDEMO,
            IEnumerable<string> group = null,
            WheelType? wheelType = null,
            TypeOfBike? typeOfBike = null,
            string description = null,
            string stationId = null,
            string stationName = null,
            Uri operatorUri = null,
            TariffDescription tariffDescription = null,
            Func<DateTime> dateTimeProvider = null,
            IStateInfo stateInfo = null)
        {
            IsDemo = isDemo;
            Group = group;
            m_oBike = new Bike(id, lockModel, wheelType, typeOfBike, description);
            m_oStateInfo = new StateInfoMutable(dateTimeProvider, stateInfo);
            m_oStateInfo.PropertyChanged += (sender, eventargs) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(eventargs.PropertyName));
            StationId = stationId;
            StationName = stationName;
            OperatorUri = operatorUri;
            TariffDescription = tariffDescription;
        }

        /// <summary> Constructs a bike object from source. </summary>
        public BikeInfoMutable(IBikeInfo bike, string stationName) : this(
            bike.Id,
            bike.LockModel,
            bike.IsDemo,
            bike.Group,
            bike.WheelType,
            bike.TypeOfBike,
            bike.Description,
            bike.StationId,
            stationName,
            bike.OperatorUri,
            bike.TariffDescription,
            null,
            bike.State)
        {
        }

        /// <summary> Id of station a which bike is located, null otherwise.</summary>
        [DataMember]
        public string StationId { get; }

        /// <summary> Name of station a which bike is located, null otherwise. </summary>
        [DataMember]
        public string StationName { get; }

        /// <summary> Holds description about the tarif. </summary>
        [DataMember]
        public TariffDescription TariffDescription { get; private set; }

        /// <summary>
        /// Holds the rent state of the bike.
        /// </summary>
        [DataMember]
        public StateInfoMutable State
        {
            get { return m_oStateInfo; }
        }

        /// <summary>
        /// Uri of the operator or null, in case of single operator setup.
        /// </summary>
        public Uri OperatorUri { get; }

        /// <summary> Unused member. </summary>
        IStateInfoMutable IBikeInfoMutable.State => m_oStateInfo;

        public string Id => m_oBike.Id;

        public bool IsDemo { get; }

        /// <summary> Returns the group (TINK, Konrad, ...). </summary>
        public IEnumerable<string> Group { get; }

        public WheelType? WheelType => m_oBike.WheelType;

        public TypeOfBike? TypeOfBike => m_oBike.TypeOfBike;

        public LockModel LockModel => m_oBike.LockModel;

        public string Description => m_oBike.Description;

        /// <summary>
        /// Fired whenever  property of bike changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Converts the instance to text.
        /// </summary>
        /// <returns></returns>
        public new string ToString()
        {
            return $"Id={Id}{(WheelType != null ? $", wheel(s)={WheelType}" : string.Empty)}{(TypeOfBike != null ? $", type={TypeOfBike}" : "")}, demo={IsDemo}, state={State.ToString()}, location={(!string.IsNullOrEmpty(StationId) ? $"Station {StationId}" : "On the road")}.";
        }
    }
}