using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Brizco.Domain.Dtos.LargDtos;
using Brizco.Domain.Dtos.SmallDtos;
using Brizco.Domain.Entities.Task;
using Task = Brizco.Domain.Entities.Task.Task;

namespace Brizco.Domain.Mappers
{
    public static partial class TaskMapper
    {
        public static Task AdaptToTask(this TaskSDto p1)
        {
            return p1 == null ? null : new Task()
            {
                Type = p1.Type,
                Title = p1.Title,
                Description = p1.Description,
                IsDisposable = p1.IsDisposable,
                SetFor = p1.SetFor,
                HasDisposed = p1.HasDisposed,
                ScheduleType = p1.ScheduleType,
                ComplexId = p1.ComplexId,
                Amount = p1.Amount,
                AmountType = p1.AmountType,
                Id = p1.Id
            };
        }
        public static Task AdaptTo(this TaskSDto p2, Task p3)
        {
            if (p2 == null)
            {
                return null;
            }
            Task result = p3 ?? new Task();
            
            result.Type = p2.Type;
            result.Title = p2.Title;
            result.Description = p2.Description;
            result.IsDisposable = p2.IsDisposable;
            result.SetFor = p2.SetFor;
            result.HasDisposed = p2.HasDisposed;
            result.ScheduleType = p2.ScheduleType;
            result.ComplexId = p2.ComplexId;
            result.Amount = p2.Amount;
            result.AmountType = p2.AmountType;
            result.Id = p2.Id;
            return result;
            
        }
        public static Expression<Func<TaskSDto, Task>> ProjectToTask => p4 => new Task()
        {
            Type = p4.Type,
            Title = p4.Title,
            Description = p4.Description,
            IsDisposable = p4.IsDisposable,
            SetFor = p4.SetFor,
            HasDisposed = p4.HasDisposed,
            ScheduleType = p4.ScheduleType,
            ComplexId = p4.ComplexId,
            Amount = p4.Amount,
            AmountType = p4.AmountType,
            Id = p4.Id
        };
        public static TaskSDto AdaptToSDto(this Task p5)
        {
            return p5 == null ? null : new TaskSDto()
            {
                Type = p5.Type,
                Title = p5.Title,
                Description = p5.Description,
                IsDisposable = p5.IsDisposable,
                SetFor = p5.SetFor,
                HasDisposed = p5.HasDisposed,
                ComplexId = p5.ComplexId,
                ScheduleType = p5.ScheduleType,
                Amount = p5.Amount,
                AmountType = p5.AmountType,
                Id = p5.Id
            };
        }
        public static TaskSDto AdaptTo(this Task p6, TaskSDto p7)
        {
            if (p6 == null)
            {
                return null;
            }
            TaskSDto result = p7 ?? new TaskSDto();
            
            result.Type = p6.Type;
            result.Title = p6.Title;
            result.Description = p6.Description;
            result.IsDisposable = p6.IsDisposable;
            result.SetFor = p6.SetFor;
            result.HasDisposed = p6.HasDisposed;
            result.ComplexId = p6.ComplexId;
            result.ScheduleType = p6.ScheduleType;
            result.Amount = p6.Amount;
            result.AmountType = p6.AmountType;
            result.Id = p6.Id;
            return result;
            
        }
        public static Expression<Func<Task, TaskSDto>> ProjectToSDto => p8 => new TaskSDto()
        {
            Type = p8.Type,
            Title = p8.Title,
            Description = p8.Description,
            IsDisposable = p8.IsDisposable,
            SetFor = p8.SetFor,
            HasDisposed = p8.HasDisposed,
            ComplexId = p8.ComplexId,
            ScheduleType = p8.ScheduleType,
            Amount = p8.Amount,
            AmountType = p8.AmountType,
            Id = p8.Id
        };
        public static Task AdaptToTask(this TaskLDto p9)
        {
            return p9 == null ? null : new Task()
            {
                Type = p9.Type,
                Title = p9.Title,
                Description = p9.Description,
                IsDisposable = p9.IsDisposable,
                SetFor = p9.SetFor,
                HasDisposed = p9.HasDisposed,
                ScheduleType = p9.ScheduleType,
                Amount = p9.Amount,
                AmountType = p9.AmountType,
                Shifts = funcMain1(p9.Shifts),
                Days = funcMain2(p9.Days),
                Routines = funcMain3(p9.Routines),
                Positions = funcMain4(p9.Positions),
                Id = p9.Id
            };
        }
        public static Task AdaptTo(this TaskLDto p14, Task p15)
        {
            if (p14 == null)
            {
                return null;
            }
            Task result = p15 ?? new Task();
            
            result.Type = p14.Type;
            result.Title = p14.Title;
            result.Description = p14.Description;
            result.IsDisposable = p14.IsDisposable;
            result.SetFor = p14.SetFor;
            result.HasDisposed = p14.HasDisposed;
            result.ScheduleType = p14.ScheduleType;
            result.Amount = p14.Amount;
            result.AmountType = p14.AmountType;
            result.Shifts = funcMain5(p14.Shifts, result.Shifts);
            result.Days = funcMain6(p14.Days, result.Days);
            result.Routines = funcMain7(p14.Routines, result.Routines);
            result.Positions = funcMain8(p14.Positions, result.Positions);
            result.Id = p14.Id;
            return result;
            
        }
        public static Expression<Func<TaskLDto, Task>> ProjectLDtoToTask => p24 => new Task()
        {
            Type = p24.Type,
            Title = p24.Title,
            Description = p24.Description,
            IsDisposable = p24.IsDisposable,
            SetFor = p24.SetFor,
            HasDisposed = p24.HasDisposed,
            ScheduleType = p24.ScheduleType,
            Amount = p24.Amount,
            AmountType = p24.AmountType,
            Shifts = p24.Shifts.Select<TaskShiftSDto, TaskShift>(p25 => new TaskShift()
            {
                TaskId = p25.TaskId,
                ShiftId = p25.ShiftId
            }).ToList<TaskShift>(),
            Days = p24.Days.Select<TaskDaySDto, TaskDay>(p26 => new TaskDay()
            {
                DayOfWeek = p26.DayOfWeek,
                TaskId = p26.TaskId,
                Id = p26.Id
            }).ToList<TaskDay>(),
            Routines = p24.Routines.Select<TaskRoutineSDto, TaskRoutine>(p27 => new TaskRoutine()
            {
                TaskId = p27.TaskId,
                RoutineId = p27.RoutineId,
                Id = p27.Id
            }).ToList<TaskRoutine>(),
            Positions = p24.Positions.Select<TaskPositionSDto, TaskPosition>(p28 => new TaskPosition()
            {
                PositionId = p28.PositionId,
                TaskId = p28.TaskId,
                Id = p28.Id
            }).ToList<TaskPosition>(),
            Id = p24.Id
        };
        public static TaskLDto AdaptToLDto(this Task p29)
        {
            return p29 == null ? null : new TaskLDto()
            {
                Type = p29.Type,
                Title = p29.Title,
                Description = p29.Description,
                IsDisposable = p29.IsDisposable,
                SetFor = p29.SetFor,
                HasDisposed = p29.HasDisposed,
                ScheduleType = p29.ScheduleType,
                Amount = p29.Amount,
                AmountType = p29.AmountType,
                Shifts = funcMain9(p29.Shifts),
                Positions = funcMain10(p29.Positions),
                Days = funcMain11(p29.Days),
                Routines = funcMain12(p29.Routines),
                Id = p29.Id
            };
        }
        public static TaskLDto AdaptTo(this Task p34, TaskLDto p35)
        {
            if (p34 == null)
            {
                return null;
            }
            TaskLDto result = p35 ?? new TaskLDto();
            
            result.Type = p34.Type;
            result.Title = p34.Title;
            result.Description = p34.Description;
            result.IsDisposable = p34.IsDisposable;
            result.SetFor = p34.SetFor;
            result.HasDisposed = p34.HasDisposed;
            result.ScheduleType = p34.ScheduleType;
            result.Amount = p34.Amount;
            result.AmountType = p34.AmountType;
            result.Shifts = funcMain13(p34.Shifts, result.Shifts);
            result.Positions = funcMain14(p34.Positions, result.Positions);
            result.Days = funcMain15(p34.Days, result.Days);
            result.Routines = funcMain16(p34.Routines, result.Routines);
            result.Id = p34.Id;
            return result;
            
        }
        public static Expression<Func<Task, TaskLDto>> ProjectToLDto => p44 => new TaskLDto()
        {
            Type = p44.Type,
            Title = p44.Title,
            Description = p44.Description,
            IsDisposable = p44.IsDisposable,
            SetFor = p44.SetFor,
            HasDisposed = p44.HasDisposed,
            ScheduleType = p44.ScheduleType,
            Amount = p44.Amount,
            AmountType = p44.AmountType,
            Shifts = p44.Shifts.Select<TaskShift, TaskShiftSDto>(p45 => new TaskShiftSDto()
            {
                ShiftId = p45.ShiftId,
                TaskId = p45.TaskId
            }).ToList<TaskShiftSDto>(),
            Positions = p44.Positions.Select<TaskPosition, TaskPositionSDto>(p46 => new TaskPositionSDto()
            {
                PositionId = p46.PositionId,
                TaskId = p46.TaskId,
                Id = p46.Id
            }).ToList<TaskPositionSDto>(),
            Days = p44.Days.Select<TaskDay, TaskDaySDto>(p47 => new TaskDaySDto()
            {
                DayOfWeek = p47.DayOfWeek,
                TaskId = p47.TaskId,
                Id = p47.Id
            }).ToList<TaskDaySDto>(),
            Routines = p44.Routines.Select<TaskRoutine, TaskRoutineSDto>(p48 => new TaskRoutineSDto()
            {
                TaskId = p48.TaskId,
                RoutineId = p48.RoutineId,
                Id = p48.Id
            }).ToList<TaskRoutineSDto>(),
            Id = p44.Id
        };
        
        private static List<TaskShift> funcMain1(List<TaskShiftSDto> p10)
        {
            if (p10 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p10.Count);
            
            int i = 0;
            int len = p10.Count;
            
            while (i < len)
            {
                TaskShiftSDto item = p10[i];
                result.Add(item == null ? null : new TaskShift()
                {
                    TaskId = item.TaskId,
                    ShiftId = item.ShiftId
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain2(List<TaskDaySDto> p11)
        {
            if (p11 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p11.Count);
            
            int i = 0;
            int len = p11.Count;
            
            while (i < len)
            {
                TaskDaySDto item = p11[i];
                result.Add(item == null ? null : new TaskDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain3(List<TaskRoutineSDto> p12)
        {
            if (p12 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p12.Count);
            
            int i = 0;
            int len = p12.Count;
            
            while (i < len)
            {
                TaskRoutineSDto item = p12[i];
                result.Add(item == null ? null : new TaskRoutine()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain4(List<TaskPositionSDto> p13)
        {
            if (p13 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p13.Count);
            
            int i = 0;
            int len = p13.Count;
            
            while (i < len)
            {
                TaskPositionSDto item = p13[i];
                result.Add(item == null ? null : new TaskPosition()
                {
                    PositionId = item.PositionId,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShift> funcMain5(List<TaskShiftSDto> p16, List<TaskShift> p17)
        {
            if (p16 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p16.Count);
            
            int i = 0;
            int len = p16.Count;
            
            while (i < len)
            {
                TaskShiftSDto item = p16[i];
                result.Add(item == null ? null : new TaskShift()
                {
                    TaskId = item.TaskId,
                    ShiftId = item.ShiftId
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain6(List<TaskDaySDto> p18, List<TaskDay> p19)
        {
            if (p18 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p18.Count);
            
            int i = 0;
            int len = p18.Count;
            
            while (i < len)
            {
                TaskDaySDto item = p18[i];
                result.Add(item == null ? null : new TaskDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain7(List<TaskRoutineSDto> p20, List<TaskRoutine> p21)
        {
            if (p20 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p20.Count);
            
            int i = 0;
            int len = p20.Count;
            
            while (i < len)
            {
                TaskRoutineSDto item = p20[i];
                result.Add(item == null ? null : new TaskRoutine()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain8(List<TaskPositionSDto> p22, List<TaskPosition> p23)
        {
            if (p22 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p22.Count);
            
            int i = 0;
            int len = p22.Count;
            
            while (i < len)
            {
                TaskPositionSDto item = p22[i];
                result.Add(item == null ? null : new TaskPosition()
                {
                    PositionId = item.PositionId,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShiftSDto> funcMain9(List<TaskShift> p30)
        {
            if (p30 == null)
            {
                return null;
            }
            List<TaskShiftSDto> result = new List<TaskShiftSDto>(p30.Count);
            
            int i = 0;
            int len = p30.Count;
            
            while (i < len)
            {
                TaskShift item = p30[i];
                result.Add(item == null ? null : new TaskShiftSDto()
                {
                    ShiftId = item.ShiftId,
                    TaskId = item.TaskId
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPositionSDto> funcMain10(List<TaskPosition> p31)
        {
            if (p31 == null)
            {
                return null;
            }
            List<TaskPositionSDto> result = new List<TaskPositionSDto>(p31.Count);
            
            int i = 0;
            int len = p31.Count;
            
            while (i < len)
            {
                TaskPosition item = p31[i];
                result.Add(item == null ? null : new TaskPositionSDto()
                {
                    PositionId = item.PositionId,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDaySDto> funcMain11(List<TaskDay> p32)
        {
            if (p32 == null)
            {
                return null;
            }
            List<TaskDaySDto> result = new List<TaskDaySDto>(p32.Count);
            
            int i = 0;
            int len = p32.Count;
            
            while (i < len)
            {
                TaskDay item = p32[i];
                result.Add(item == null ? null : new TaskDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutineSDto> funcMain12(List<TaskRoutine> p33)
        {
            if (p33 == null)
            {
                return null;
            }
            List<TaskRoutineSDto> result = new List<TaskRoutineSDto>(p33.Count);
            
            int i = 0;
            int len = p33.Count;
            
            while (i < len)
            {
                TaskRoutine item = p33[i];
                result.Add(item == null ? null : new TaskRoutineSDto()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShiftSDto> funcMain13(List<TaskShift> p36, List<TaskShiftSDto> p37)
        {
            if (p36 == null)
            {
                return null;
            }
            List<TaskShiftSDto> result = new List<TaskShiftSDto>(p36.Count);
            
            int i = 0;
            int len = p36.Count;
            
            while (i < len)
            {
                TaskShift item = p36[i];
                result.Add(item == null ? null : new TaskShiftSDto()
                {
                    ShiftId = item.ShiftId,
                    TaskId = item.TaskId
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPositionSDto> funcMain14(List<TaskPosition> p38, List<TaskPositionSDto> p39)
        {
            if (p38 == null)
            {
                return null;
            }
            List<TaskPositionSDto> result = new List<TaskPositionSDto>(p38.Count);
            
            int i = 0;
            int len = p38.Count;
            
            while (i < len)
            {
                TaskPosition item = p38[i];
                result.Add(item == null ? null : new TaskPositionSDto()
                {
                    PositionId = item.PositionId,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDaySDto> funcMain15(List<TaskDay> p40, List<TaskDaySDto> p41)
        {
            if (p40 == null)
            {
                return null;
            }
            List<TaskDaySDto> result = new List<TaskDaySDto>(p40.Count);
            
            int i = 0;
            int len = p40.Count;
            
            while (i < len)
            {
                TaskDay item = p40[i];
                result.Add(item == null ? null : new TaskDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutineSDto> funcMain16(List<TaskRoutine> p42, List<TaskRoutineSDto> p43)
        {
            if (p42 == null)
            {
                return null;
            }
            List<TaskRoutineSDto> result = new List<TaskRoutineSDto>(p42.Count);
            
            int i = 0;
            int len = p42.Count;
            
            while (i < len)
            {
                TaskRoutine item = p42[i];
                result.Add(item == null ? null : new TaskRoutineSDto()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
    }
}