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.Complex;
using Brizco.Domain.Entities.Shift;
using Mapster.Models;

namespace Brizco.Domain.Mappers
{
    public static partial class ShiftMapper
    {
        public static Shift AdaptToShift(this ShiftSDto p1)
        {
            return p1 == null ? null : new Shift()
            {
                Title = p1.Title,
                StartAt = p1.StartAt,
                EndAt = p1.EndAt,
                Description = p1.Description,
                ComplexId = p1.ComplexId,
                Complex = new Complex() {Id = p1.ComplexId},
                Days = funcMain1(p1.Days),
                Id = p1.Id
            };
        }
        public static Shift AdaptTo(this ShiftSDto p3, Shift p4)
        {
            if (p3 == null)
            {
                return null;
            }
            Shift result = p4 ?? new Shift();
            
            result.Title = p3.Title;
            result.StartAt = p3.StartAt;
            result.EndAt = p3.EndAt;
            result.Description = p3.Description;
            result.ComplexId = p3.ComplexId;
            result.Complex = funcMain2(new Never(), result.Complex, p3);
            result.Days = funcMain3(p3.Days, result.Days);
            result.Id = p3.Id;
            return result;
            
        }
        public static Expression<Func<ShiftSDto, Shift>> ProjectToShift => p9 => new Shift()
        {
            Title = p9.Title,
            StartAt = p9.StartAt,
            EndAt = p9.EndAt,
            Description = p9.Description,
            ComplexId = p9.ComplexId,
            Complex = new Complex() {Id = p9.ComplexId},
            Days = p9.Days.Select<DayOfWeek, ShiftDay>(p10 => new ShiftDay() {}).ToList<ShiftDay>(),
            Id = p9.Id
        };
        public static ShiftSDto AdaptToSDto(this Shift p11)
        {
            return p11 == null ? null : new ShiftSDto()
            {
                Title = p11.Title,
                Description = p11.Description,
                StartAt = p11.StartAt,
                EndAt = p11.EndAt,
                ComplexId = p11.ComplexId,
                Days = funcMain4(p11.Days.Select<ShiftDay, DayOfWeek>(funcMain5).ToList<DayOfWeek>()),
                Id = p11.Id
            };
        }
        public static ShiftSDto AdaptTo(this Shift p13, ShiftSDto p14)
        {
            if (p13 == null)
            {
                return null;
            }
            ShiftSDto result = p14 ?? new ShiftSDto();
            
            result.Title = p13.Title;
            result.Description = p13.Description;
            result.StartAt = p13.StartAt;
            result.EndAt = p13.EndAt;
            result.ComplexId = p13.ComplexId;
            result.Days = funcMain6(p13.Days.Select<ShiftDay, DayOfWeek>(funcMain5).ToList<DayOfWeek>(), result.Days);
            result.Id = p13.Id;
            return result;
            
        }
        public static Expression<Func<Shift, ShiftSDto>> ProjectToSDto => p17 => new ShiftSDto()
        {
            Title = p17.Title,
            Description = p17.Description,
            StartAt = p17.StartAt,
            EndAt = p17.EndAt,
            ComplexId = p17.ComplexId,
            Days = p17.Days.Select<ShiftDay, DayOfWeek>(d => d.DayOfWeek).ToList<DayOfWeek>(),
            Id = p17.Id
        };
        public static Shift AdaptToShift(this ShiftLDto p18)
        {
            return p18 == null ? null : new Shift()
            {
                Title = p18.Title,
                StartAt = p18.StartAt,
                EndAt = p18.EndAt,
                Description = p18.Description,
                ComplexId = p18.ComplexId,
                Days = funcMain7(p18.Days),
                Id = p18.Id
            };
        }
        public static Shift AdaptTo(this ShiftLDto p20, Shift p21)
        {
            if (p20 == null)
            {
                return null;
            }
            Shift result = p21 ?? new Shift();
            
            result.Title = p20.Title;
            result.StartAt = p20.StartAt;
            result.EndAt = p20.EndAt;
            result.Description = p20.Description;
            result.ComplexId = p20.ComplexId;
            result.Days = funcMain8(p20.Days, result.Days);
            result.Id = p20.Id;
            return result;
            
        }
        public static Expression<Func<ShiftLDto, Shift>> ProjectLDtoToShift => p24 => new Shift()
        {
            Title = p24.Title,
            StartAt = p24.StartAt,
            EndAt = p24.EndAt,
            Description = p24.Description,
            ComplexId = p24.ComplexId,
            Days = p24.Days.Select<ShiftDaySDto, ShiftDay>(p25 => new ShiftDay()
            {
                DayOfWeek = p25.DayOfWeek,
                ShiftId = p25.ShiftId,
                Id = p25.Id
            }).ToList<ShiftDay>(),
            Id = p24.Id
        };
        public static ShiftLDto AdaptToLDto(this Shift p26)
        {
            return p26 == null ? null : new ShiftLDto()
            {
                Title = p26.Title,
                Description = p26.Description,
                StartAt = p26.StartAt,
                EndAt = p26.EndAt,
                ComplexId = p26.ComplexId,
                Days = funcMain9(p26.Days),
                Id = p26.Id
            };
        }
        public static ShiftLDto AdaptTo(this Shift p28, ShiftLDto p29)
        {
            if (p28 == null)
            {
                return null;
            }
            ShiftLDto result = p29 ?? new ShiftLDto();
            
            result.Title = p28.Title;
            result.Description = p28.Description;
            result.StartAt = p28.StartAt;
            result.EndAt = p28.EndAt;
            result.ComplexId = p28.ComplexId;
            result.Days = funcMain10(p28.Days, result.Days);
            result.Id = p28.Id;
            return result;
            
        }
        public static Expression<Func<Shift, ShiftLDto>> ProjectToLDto => p32 => new ShiftLDto()
        {
            Title = p32.Title,
            Description = p32.Description,
            StartAt = p32.StartAt,
            EndAt = p32.EndAt,
            ComplexId = p32.ComplexId,
            Days = p32.Days.Select<ShiftDay, ShiftDaySDto>(p33 => new ShiftDaySDto()
            {
                DayOfWeek = p33.DayOfWeek,
                ShiftId = p33.ShiftId,
                Id = p33.Id
            }).ToList<ShiftDaySDto>(),
            Id = p32.Id
        };
        
        private static List<ShiftDay> funcMain1(List<DayOfWeek> p2)
        {
            if (p2 == null)
            {
                return null;
            }
            List<ShiftDay> result = new List<ShiftDay>(p2.Count);
            
            int i = 0;
            int len = p2.Count;
            
            while (i < len)
            {
                DayOfWeek item = p2[i];
                result.Add(new ShiftDay() {});
                i++;
            }
            return result;
            
        }
        
        private static Complex funcMain2(Never p5, Complex p6, ShiftSDto p3)
        {
            Complex result = p6 ?? new Complex();
            
            result.Id = p3.ComplexId;
            return result;
            
        }
        
        private static List<ShiftDay> funcMain3(List<DayOfWeek> p7, List<ShiftDay> p8)
        {
            if (p7 == null)
            {
                return null;
            }
            List<ShiftDay> result = new List<ShiftDay>(p7.Count);
            
            int i = 0;
            int len = p7.Count;
            
            while (i < len)
            {
                DayOfWeek item = p7[i];
                result.Add(new ShiftDay() {});
                i++;
            }
            return result;
            
        }
        
        private static List<DayOfWeek> funcMain4(List<DayOfWeek> p12)
        {
            if (p12 == null)
            {
                return null;
            }
            List<DayOfWeek> result = new List<DayOfWeek>(p12.Count);
            
            int i = 0;
            int len = p12.Count;
            
            while (i < len)
            {
                DayOfWeek item = p12[i];
                result.Add(item);
                i++;
            }
            return result;
            
        }
        
        private static DayOfWeek funcMain5(ShiftDay d)
        {
            return d.DayOfWeek;
        }
        
        private static List<DayOfWeek> funcMain6(List<DayOfWeek> p15, List<DayOfWeek> p16)
        {
            if (p15 == null)
            {
                return null;
            }
            List<DayOfWeek> result = new List<DayOfWeek>(p15.Count);
            
            int i = 0;
            int len = p15.Count;
            
            while (i < len)
            {
                DayOfWeek item = p15[i];
                result.Add(item);
                i++;
            }
            return result;
            
        }
        
        private static List<ShiftDay> funcMain7(List<ShiftDaySDto> p19)
        {
            if (p19 == null)
            {
                return null;
            }
            List<ShiftDay> result = new List<ShiftDay>(p19.Count);
            
            int i = 0;
            int len = p19.Count;
            
            while (i < len)
            {
                ShiftDaySDto item = p19[i];
                result.Add(item == null ? null : new ShiftDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    ShiftId = item.ShiftId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<ShiftDay> funcMain8(List<ShiftDaySDto> p22, List<ShiftDay> p23)
        {
            if (p22 == null)
            {
                return null;
            }
            List<ShiftDay> result = new List<ShiftDay>(p22.Count);
            
            int i = 0;
            int len = p22.Count;
            
            while (i < len)
            {
                ShiftDaySDto item = p22[i];
                result.Add(item == null ? null : new ShiftDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    ShiftId = item.ShiftId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<ShiftDaySDto> funcMain9(List<ShiftDay> p27)
        {
            if (p27 == null)
            {
                return null;
            }
            List<ShiftDaySDto> result = new List<ShiftDaySDto>(p27.Count);
            
            int i = 0;
            int len = p27.Count;
            
            while (i < len)
            {
                ShiftDay item = p27[i];
                result.Add(item == null ? null : new ShiftDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    ShiftId = item.ShiftId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<ShiftDaySDto> funcMain10(List<ShiftDay> p30, List<ShiftDaySDto> p31)
        {
            if (p30 == null)
            {
                return null;
            }
            List<ShiftDaySDto> result = new List<ShiftDaySDto>(p30.Count);
            
            int i = 0;
            int len = p30.Count;
            
            while (i < len)
            {
                ShiftDay item = p30[i];
                result.Add(item == null ? null : new ShiftDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    ShiftId = item.ShiftId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
    }
}