using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using Tensorflow.Keras.ArgsDefinition;
using Tensorflow.Keras.Datasets;
using Tensorflow.Keras.Engine;
using Tensorflow.Keras.Layers;
using Tensorflow.Keras.Losses;
using Tensorflow.Keras.Metrics;
using Tensorflow.Keras.Models;
using Tensorflow.Keras.Optimizers;
using Tensorflow.Keras.Saving;
using Tensorflow.Keras.Utils;

namespace Tensorflow.Keras
{
    public class KerasInterface
    {
        public KerasDataset datasets { get; } = new KerasDataset();
        public Initializers initializers { get; } = new Initializers();
        public Regularizers regularizers { get; } = new Regularizers();
        public LayersApi layers { get; } = new LayersApi();
        public LossesApi losses { get; } = new LossesApi();
        public Activations activations { get; } = new Activations();
        public Preprocessing preprocessing { get; } = new Preprocessing();
        public BackendImpl backend { get; } = new BackendImpl();
        public OptimizerApi optimizers { get; } = new OptimizerApi();
        public MetricsApi metrics { get; } = new MetricsApi();
        public ModelsApi models { get; } = new ModelsApi();
        public KerasUtils utils { get; } = new KerasUtils();

        public Sequential Sequential(List<ILayer> layers = null,
                string name = null)
            => new Sequential(new SequentialArgs
            {
                Layers = layers,
                Name = name
            });

        /// <summary>
        /// `Model` groups layers into an object with training and inference features.
        /// </summary>
        /// <param name="input"></param>
        /// <param name="output"></param>
        /// <returns></returns>
        public Functional Model(Tensors inputs, Tensors outputs, string name = null)
            => new Functional(inputs, outputs, name: name);

        /// <summary>
        /// Instantiate a Keras tensor.
        /// </summary>
        /// <param name="shape"></param>
        /// <param name="batch_size"></param>
        /// <param name="dtype"></param>
        /// <param name="name"></param>
        /// <param name="sparse">
        /// A boolean specifying whether the placeholder to be created is sparse.
        /// </param>
        /// <param name="ragged">
        /// A boolean specifying whether the placeholder to be created is ragged.
        /// </param>
        /// <param name="tensor">
        /// Optional existing tensor to wrap into the `Input` layer.
        /// If set, the layer will not create a placeholder tensor.
        /// </param>
        /// <returns></returns>
        public Tensor Input(TensorShape shape = null,
                int batch_size = -1,
                TensorShape batch_input_shape = null,
                TF_DataType dtype = TF_DataType.DtInvalid,
                string name = null,
                bool sparse = false,
                bool ragged = false,
                Tensor tensor = null)
        {
            if (batch_input_shape != null)
                shape = batch_input_shape.dims.Skip(1).ToArray();

            var args = new InputLayerArgs
            {
                Name = name,
                InputShape = shape,
                BatchInputShape = batch_input_shape,
                BatchSize = batch_size,
                DType = dtype,
                Sparse = sparse,
                Ragged = ragged,
                InputTensor = tensor
            };

            var layer = new InputLayer(args);

            return layer.InboundNodes[0].Outputs;
        }
    }
}