using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using System.Data.Common;
using Developpez.Dotnet.Data;
using System.Data;
using System.Transactions;
using System.IO;

namespace Developpez.Dotnet.Tests.Data
{
    [TestFixture]
    public class DataExtensionsTests
    {
        #region Méthodes utilitaires

        private DbProviderFactory GetFactory()
        {
            return DbProviderFactories.GetFactory("System.Data.SqlServerCe.3.5");
        }

        private DbConnection GetTestDBConnection()
        {
            DbProviderFactory factory = GetFactory();
            DbConnection connection = factory.CreateConnection();
            connection.ConnectionString = string.Format(@"Data Source={0}\Data\TestDB.sdf", Environment.CurrentDirectory);
            return connection;
        }

        private DbCommand GetPersonsQuery(DbConnection connection)
        {
            DbCommand command = connection.CreateCommand();
            command.CommandText = "SELECT * FROM Persons";
            return command;
        }

        #endregion

        [Test]
        public void Test_IDataRecord_Field()
        {
            using (var connection = GetTestDBConnection())
            {
                connection.Open();
                using (var command = GetPersonsQuery(connection))
                {
                    using (var reader = command.ExecuteReader())
                    {
                        foreach (var record in reader.Cast<IDataRecord>())
                        {
                            // Type valeur, colonne non nullable
                            Guid id = record.Field<Guid>("Id");

                            // Type référence, colonne non nullable
                            string lastName = record.Field<string>("LastName");

                            // Type référence, colonne nullable
                            string firstName = record.Field<string>("FirstName");

                            // Type valeur, colonne nullable
                            DateTime? dateOfBirth = record.Field<DateTime?>("DateOfBirth");

                            // Type valeur, colonne nullable
                            int? luckyNumber = record.Field<int?>("LuckyNumber");

                            // Type valeur, colonne nullable, avec conversion
                            long longLuckyNumber = record.Field<long?>("LuckyNumber", true) ?? 0;
                        }
                    }
                }
            }
        }

        [Test]
        public void Test_IDataRecord_GetStream()
        {
            using (var connection = GetTestDBConnection())
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    connection.Open();

                    byte[] pic = new byte[2000];
                    Random random = new Random();
                    random.NextBytes(pic);

                    using (var command = connection.CreateCommand())
                    {
                        command.CommandText = "INSERT INTO Pictures (Id, Name, Description, Picture) VALUES (@id, @name, @description, @picture)";
                        command.AddParameter("@id", DbType.Guid).Value = Guid.NewGuid();
                        command.AddParameter("@name", DbType.String).Value = "Test";
                        command.AddParameter("@description", DbType.String).Value = "Test";
                        command.AddParameter("@picture", DbType.Binary).Value = pic;
                        command.ExecuteNonQuery();
                    }

                    using (var command = connection.CreateCommand())
                    {
                        command.CommandText = "SELECT * FROM Pictures";
                        using (DbDataReader reader = command.ExecuteReader())
                        {
                            if (reader.Read())
                            {
                                using (Stream stream = reader.GetStream("Picture"))
                                {
                                    byte[] pic2 = new byte[stream.Length];
                                    stream.Read(pic2, 0, pic2.Length);
                                    Assert2.AreSequenceEqual(pic, pic2);
                                }
                            }
                        }
                    }
                }
            }
        }

        [Test]
        public void Test_DbDataAdapter_AddRowUpdateEventHandler()
        {
            DataTable table = new DataTable();
            var factory = GetFactory();

            using (TransactionScope scope = new TransactionScope())
            {
                using (var connection = GetTestDBConnection())
                using (var command = GetPersonsQuery(connection))
                using (var adapter = factory.CreateDataAdapter())
                {
                    adapter.SelectCommand = command;
                    var builder = factory.CreateCommandBuilder();
                    builder.DataAdapter = adapter;

                    bool updatingHandlerCalled = false;
                    bool updatedHandlerCalled = false;

                    adapter.AddRowUpdatingHandler((sender, e) => updatingHandlerCalled = true);
                    adapter.AddRowUpdatedHandler((sender, e) => updatedHandlerCalled = true);

                    connection.Open();
                    adapter.Fill(table);

                    table.Rows[0]["FirstName"] = "Joe";
                    table.Rows[1]["LuckyNumber"] = 7;
                    adapter.Update(table);
                    Assert.IsTrue(updatingHandlerCalled);
                    Assert.IsTrue(updatedHandlerCalled);

                    table.Rows.Clear();
                    adapter.Fill(table);
                }
            }
        }
    }
}