using System.Collections.Generic;
using System;
using System.Linq;

namespace Tensorflow.Eager
{
    public class Execute
    {
        /// <summary>
        /// Execute a TensorFlow operation.
        /// </summary>
        /// <param name="op_name">
        /// Name of the TensorFlow operation (see REGISTER_OP in C++ code) to 
        /// execute.
        /// </param>
        /// <param name="num_outputs">
        /// The number of outputs of the operation to fetch.
        /// </param>
        /// <param name="inputs">
        /// A list of inputs to the operation. Each entry should be a Tensor, or
        /// a value which can be passed to the Tensor constructor to create one.
        /// </param>
        /// <param name="attrs">
        /// A tuple with alternating string attr names and attr values for this
        /// operation.
        /// </param>
        /// <param name="ctx">The value of context.context().</param>
        /// <param name="name">Customized name for the operation.</param>
        /// <returns>List of output Tensor objects. The list is empty if there are no outputs</returns>
        public Tensor execute(Context ctx, string op_name, int num_outputs, 
            Tensor[] inputs, object[] attrs, 
            string name = null)
        {
            ctx.ensure_initialized();

            // TFE_TensorHandle
            using var status = new Status();
            /*var retVals = wrap_tfe_src.TFE_Execute(ctx, ctx.device_name, op_name, inputs, attrs, num_outputs, status);

            return new EagerTensor((TFE_TensorHandle)retVals[0]);*/

            IntPtr[] outputs = new IntPtr[num_outputs];
            c_api.TFE_QuickExecute(ctx,
                ctx.device_name,
               op_name,
               inputs.Select(x => (x as EagerTensor).GetTfeTensorHandle()).ToArray(), 
               inputs.Length,
               op => wrap_tfe_src.SetOpAttrs(op, attrs),
               outputs, 
               num_outputs,
               status);
            status.Check(true);

            TFE_TensorHandle tfe_tensor_handle = outputs[0];
            return new EagerTensor(tfe_tensor_handle);
        }

        public (TF_DataType, Tensor[]) args_to_matching_eager(Context ctx, TF_DataType default_dtype = TF_DataType.DtInvalid, object[] args = null)
        {
            if (args.Length == 0 && default_dtype != TF_DataType.DtInvalid)
                return (default_dtype, null);

            if (args.Count(x => x is EagerTensor) == args.Length)
                return ((args[0] as EagerTensor).dtype, args.Select(x => x as EagerTensor).ToArray());

            var dtype = TF_DataType.DtInvalid;
            foreach (var x in args)
            {
                if (x is EagerTensor et)
                    dtype = et.dtype;
            }

            if (dtype == TF_DataType.DtInvalid)
            {
                var ret = new List<Tensor>();
                foreach (var t in args)
                {
                    ret.Add(ops.convert_to_tensor(t, dtype, preferred_dtype: default_dtype, ctx: ctx));
                    if (dtype == TF_DataType.DtInvalid)
                        dtype = ret.Last().dtype;
                }

                return (dtype, ret.ToArray());
            }
            else
                throw new NotImplementedException("");
        }
    }
}