namespace RepositoryTest.Controllers
{
  [RoutePrefix("api/Person")]
  public class PersonController : BaseApiController
  {
    public PersonController(IUnitOfWork uow)
    {
    }

    [HttpDelete]
    [Route("{id:long}")]
    [SwaggerResponse(HttpStatusCode.OK, "", typeof(void))]
    public IHttpActionResult Delete(long id)
    {
      using (TransactionScope scope = new TransactionScope(
        TransactionScopeOption.Required, TRANSACTION_OPTIONS))
      {
        try
        {
          Person person = UoW.Person.GetById(id);
          if (person == null)
            return NotFound();
          UoW.Person.Delete(person);
          scope.Complete();
          return Ok();
        }
        catch
        {
          scope.Dispose();
          throw;
        }
      }
    }

    [HttpGet]
    [Route("Find/{nome}")]
    [SwaggerResponse(HttpStatusCode.OK, "", typeof(IEnumerable<PersonDTO>))]
    public IHttpActionResult FindByNome(string nome) =>
      Ok(UoW.Person.GetUsersWithHobbiesByName(nome));

    [HttpGet]
    [Route("")]
    [SwaggerResponse(HttpStatusCode.OK, "", typeof(IEnumerable<PersonDTO>))]
    public IHttpActionResult Get() =>
      Ok(UoW.Person.GetAllWithHobbies().ToList());

    [HttpGet]
    [Route("{id:long}")]
    [SwaggerResponse(HttpStatusCode.OK, "", typeof(PersonDTO))]
    public IHttpActionResult GetById(long id)
    {
      PersonDTO user = UoW.Person.GetUserWithHobbiesById(id);
      if (user == null)
        return NotFound();
      return Ok(user);
    }

    [HttpPost]
    [Route("")]
    [SwaggerResponse(HttpStatusCode.Created, "", typeof(PersonDTO))]
    [ValidateModelFilter]
    public IHttpActionResult Post(PersonUpdateDto person)
    {
      using (TransactionScope scope = new TransactionScope(
        TransactionScopeOption.Required, TRANSACTION_OPTIONS))
      {
        try
        {
          PersonDTO model = UoW.Person.CreateWithHobbies(person);
          scope.Complete();
          return CreatedAtRoute("DefaultApi", new
          {
            controller = "Person",
            id = person.Id
          }, model);
        }
        catch
        {
          scope.Dispose();
          throw;
        }
      }
    }

    [HttpPut]
    [Route("{id:long}")]
    [SwaggerResponse(HttpStatusCode.NoContent, "", typeof(void))]
    public IHttpActionResult Update(long id, PersonUpdateDto person)
    {
      using (TransactionScope scope = new TransactionScope(
        TransactionScopeOption.Required, TRANSACTION_OPTIONS))
      {
        try
        {
          if (person.Id != id)
            return BadRequest();
          UoW.Person.UpdateWithHobbies(person);
          scope.Complete();
          return StatusCode(HttpStatusCode.NoContent);
        }
        catch
        {
          scope.Dispose();
          throw;
        }
      }
    }
  }
}

namespace RepositoryTest.BL.Repository
{
  public interface IPersonRepository : IRepositoryBase<Person>
  {
    PersonDTO CreateWithHobbies(PersonUpdateDto person);
    IEnumerable<PersonDTO> GetAllWithHobbies();
    PersonDTO GetUserWithHobbiesById(long id);
    IEnumerable<PersonDTO> GetUsersWithHobbiesByName(string name);
    void UpdateWithHobbies(PersonUpdateDto person);
  }
}

namespace RepositoryTest.BL.Repository
{
  public interface IUnitOfWork : IDisposable
  {
    IPersonRepository Person { get; set; }
  }
}

namespace RepositoryTest.BL.Services
{
  public class UnitOfWork : IUnitOfWork
  {
    private bool m_disposed;
    private readonly IRepositoryTestEntities m_context;

    [Inject]
    public IPersonRepository Person { get; set; }

    public UnitOfWork(IRepositoryTestEntities context)
    {
      m_context = context;
    }

    ~UnitOfWork()
    {
      Dispose();
    }

    public void Dispose()
    {
      Dispose(true);
      GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
      if (!m_disposed && disposing)
        m_context.Dispose();
      m_disposed = true;
    }
  }
}

namespace RepositoryTest.BL.Services
{
  public class PersonService : RepositoryBase<Person>, IPersonRepository
  {
    private readonly IRepositoryBase<Hobby> m_hobby;

    public PersonService(RepositoryTestEntities db, IRepositoryBase<Hobby> hobby)
      : base(db)
    {
      m_hobby = hobby;
    }

    public PersonDTO CreateWithHobbies(PersonUpdateDto person)
    {
      Person created = Create(person);
      foreach (long hobbyId in person.Hobbies)
        Db.R_Person_Hobby.Add(new R_Person_Hobby
        {
          HobbyId = hobbyId,
          PersonId = created.Id
        });
      Db.SaveChanges();
      return GetUserWithHobbiesById(created.Id);
    }

    public IEnumerable<PersonDTO> GetAllWithHobbies() =>
      GetWithHobbies(GetAll());

    public PersonDTO GetUserWithHobbiesById(long id)
    {
      List<PersonDTO> persons = GetWithHobbies(GetAll()
        .Where(x => x.Id == id)
        .AsQueryable())
        .ToList();
      return persons.Count == 1
        ? persons[0]
        : null;
    }

    public IEnumerable<PersonDTO> GetUsersWithHobbiesByName(string name)
    {
      IQueryable<Person> persons = GetAll()
        .Where(x => x.Nome.ToLower()
        .Contains(name.ToLower()))
        .AsQueryable();
      return GetWithHobbies(persons);
    }

    private IEnumerable<PersonDTO> GetWithHobbies(IQueryable<Person> persons)
    {
      List<Hobby> hobbies = m_hobby.GetAll().ToList();
      List<PersonDTO> results = new List<PersonDTO>();
      foreach (Person person in persons)
      {
        PersonDTO dto = person;
        IEnumerable<HobbyDTO> r = HobbyDTO.ToList(
          hobbies.Where(x => person.R_Person_Hobby
            .Select(y => y.HobbyId)
            .Contains(x.Id))
          .ToList());
        dto.Hobbies.AddRange(r);
        results.Add(dto);
      }
      return results;
    }

    public void UpdateWithHobbies(PersonUpdateDto person)
    {
      Update(person);

      List<R_Person_Hobby> hobbies = Db.R_Person_Hobby
        .Where(x => x.PersonId == person.Id)
        .ToList();

      List<long> hobbyIds = hobbies
        .Select(x => x.HobbyId)
        .ToList();

      IEnumerable<long> delete = hobbyIds.Except(person.Hobbies);
      foreach (long l in delete)
      {
        R_Person_Hobby r = hobbies.Find(x => x.HobbyId == l);
        if (r != null)
          Db.R_Person_Hobby.Remove(r);
      }

      IEnumerable<long> add = person.Hobbies.Except(hobbyIds);
      foreach (long l in add)
      {
        R_Person_Hobby r = hobbies.Find(x => x.HobbyId == l);
        if (r == null)
          Db.R_Person_Hobby.Add(new R_Person_Hobby
          {
            HobbyId = l,
            PersonId = person.Id
          });
      }

      Db.SaveChanges();
    }
  }
}

namespace RepositoryTest.BL.Services
{
  public class RepositoryBase<TRecord> : IRepositoryBase<TRecord>
    where TRecord : class
  {
    private bool m_disposed;

    private readonly DbSet<TRecord> m_dbSet;

    protected RepositoryTestEntities Db { get; }

    public RepositoryBase(RepositoryTestEntities db)
    {
      Db = db;
      m_dbSet = db.Set<TRecord>();
    }

    ~RepositoryBase()
    {
      Dispose();
    }

    public virtual TRecord Create(TRecord entity)
    {
      Db.Entry(entity).State = EntityState.Added;
      Db.SaveChanges();
      return entity;
    }

    public void Delete(object id)
    {
      TRecord entity = m_dbSet.Find(id);
      Delete(entity);
    }

    public virtual void Delete(TRecord entity)
    {
      if (Db.Entry(entity).State == EntityState.Detached)
        m_dbSet.Attach(entity);
      m_dbSet.Remove(entity);
      Db.SaveChanges();
    }

    public void Dispose()
    {
      Dispose(true);
      GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
      if (!m_disposed && disposing)
        Db.Dispose();
      m_disposed = true;
    }

    public virtual IQueryable<TRecord> GetAll() => m_dbSet;

    public virtual TRecord GetById(object id) => m_dbSet.Find(id);

    public virtual void Update(TRecord entity)
    {
      Db.Entry(entity).State = EntityState.Modified;
      Db.SaveChanges();
    }
  }
}