using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
using HeuristicLab.Services.Optimization.Billing.Model;
using HeuristicLab.Services.Optimization.Billing.Utils;
namespace HeuristicLab.Services.Optimization.Billing.DataAccess {
  public class BillingDao {

    #region Context Creation

    private BillingContext CreateContext() {
      BillingContext context = new BillingContext("name=BillingContext");
      return context;
    }

    #endregion

    #region Product Methods

    public Product FindProductById(long id) {
      using (var context = CreateContext()) {
        return context.Products.FirstOrDefault(prod => prod.ProductId == id);
      }
    }

    public IEnumerable<Product> FindProdcutBy(Expression<Func<Product, bool>> predicate) {
      using (var context = CreateContext()) {
        var products = context.Products.Where(predicate).ToList();
        return products;
      }
    }

    public IEnumerable<Product> FindProductBy(Expression<Func<Product, bool>> query, params Expression<Func<Product, object>>[] includes) {
      using (var context = CreateContext()) {
        IQueryable<Product> products = context.Products.Where(query);

        if (includes != null) {
          products = includes.Aggregate(products, (current, include) => current.Include(include));
        }

        return products.ToList();
      }
    }

    public IEnumerable<Product> FindAllProducts() {
      using (var context = CreateContext()) {
        var products = context.Products.ToList();
        return products;
      }
    }

    public void InsertOrUpdateProduct(Product entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    void DeleteProduct(Product entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    #endregion

    #region Order Methods

    public void InsertOrUpdateOrder(Order entity) {
      using (var context = CreateContext()) {
        context.Orders.Add(entity);
        context.ApplyStateChanges();
        context.SaveChanges();
      }
    }

    public IEnumerable<Order> FindOrderBy(Expression<Func<Order, bool>> predicate) {
      using (var context = CreateContext()) {
        var orders = context.Orders
          .Include(o => o.OrderLines)
          .Include(o => o.User)
          .Include(o => o.User.ContactInformation)
          .Include(o => o.Invoices)
          .Include(o => o.OrderLines.Select(ol => ol.Product))
          .Where(predicate).ToList();
        return orders;
      }
    }

    #endregion

    #region OrderLine Methods

    public OrderLine FindOrderLineById(long id) {
      using (var context = CreateContext()) {
        return context.OrderLines.FirstOrDefault(ol => ol.OrderLineId == id);
      }
    }

    public IEnumerable<OrderLine> FindOrderLineBy(Expression<Func<OrderLine, bool>> predicate) {
      using (var context = CreateContext()) {
        var orderLines = context.OrderLines.Where(predicate).ToList();
        return orderLines;
      }
    }

    public IEnumerable<OrderLine> FindAllOrderLines() {
      using (var context = CreateContext()) {
        var orderLines = context.OrderLines.ToList();
        return orderLines;
      }
    }

    public void InsertOrUpdateOrderLine(OrderLine entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    void DeleteOrderLine(OrderLine entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    #endregion

    #region User Methods

    public User FindUserById(long id) {
      using (var context = CreateContext()) {
        return context.Users.FirstOrDefault(user => user.UserId == id);
      }
    }

    public IEnumerable<User> FindUserBy(Expression<Func<User, bool>> predicate) {
      using (var context = CreateContext()) {
        var users = context.Users.Where(predicate).ToList();
        return users;
      }
    }

    public IEnumerable<User> FindAllUsers() {
      using (var context = CreateContext()) {
        var users = context.Users.ToList();
        return users;
      }
    }

    public void InsertOrUpdateUser(User entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    void DeleteUser(User entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    #endregion

    #region UsageRecords Methods

    public UsageRecord FindUsageRecordById(long id) {
      using (var context = CreateContext()) {
        return context.UsageRecords.FirstOrDefault(prod => prod.ProductId == id);
      }
    }

    public IEnumerable<UsageRecord> FindUsageRecordsBy(Expression<Func<UsageRecord, bool>> predicate) {
      using (var context = CreateContext()) {
        var records = context.UsageRecords.Where(predicate).ToList();
        return records;
      }
    }

    public IEnumerable<UsageRecord> FindAllUsageRecords() {
      using (var context = CreateContext()) {
        var records = context.UsageRecords.ToList();
        return records;
      }
    }

    public void InsertOrUpdateUsageRecord(UsageRecord entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    void DeleteUsageRecord(UsageRecord entity) {
      using (var context = CreateContext()) {
        throw new NotImplementedException();
      }
    }

    #endregion

    #region Invoice Methods

    public void InsertOrUpdateInvoice(Invoice entity) {
      using (var context = CreateContext()) {
        context.Invoices.Add(entity);
        context.ApplyStateChanges();
        context.SaveChanges();
      }
    }

    public IEnumerable<Invoice> FindInvoiceBy(Expression<Func<Invoice, bool>> predicate) {
      using (var context = CreateContext()) {
        var invoices = context.Invoices.Where(predicate).ToList();
        return invoices;
      }
    }

    #endregion
  }
}