SEToolbox.Models.StructureCubeGridModel.MirrorModel C# (CSharp) Method

        public bool MirrorModel(bool usePlane, bool oddMirror)
        {
            var xMirror = Mirror.None;
            var yMirror = Mirror.None;
            var zMirror = Mirror.None;
            var xAxis = 0;
            var yAxis = 0;
            var zAxis = 0;
            var count = 0;

            if (!usePlane)
            // Find mirror Axis.
            //if (!CubeGrid.XMirroxPlane.HasValue && !CubeGrid.YMirroxPlane.HasValue && !CubeGrid.ZMirroxPlane.HasValue)
            {
                // Find the largest contigious exterior surface to use as the mirror.
                var minX = CubeGrid.CubeBlocks.Min(c => c.Min.X);
                var maxX = CubeGrid.CubeBlocks.Max(c => c.Min.X);
                var minY = CubeGrid.CubeBlocks.Min(c => c.Min.Y);
                var maxY = CubeGrid.CubeBlocks.Max(c => c.Min.Y);
                var minZ = CubeGrid.CubeBlocks.Min(c => c.Min.Z);
                var maxZ = CubeGrid.CubeBlocks.Max(c => c.Min.Z);

                var countMinX = CubeGrid.CubeBlocks.Count(c => c.Min.X == minX);
                var countMinY = CubeGrid.CubeBlocks.Count(c => c.Min.Y == minY);
                var countMinZ = CubeGrid.CubeBlocks.Count(c => c.Min.Z == minZ);
                var countMaxX = CubeGrid.CubeBlocks.Count(c => c.Min.X == maxX);
                var countMaxY = CubeGrid.CubeBlocks.Count(c => c.Min.Y == maxY);
                var countMaxZ = CubeGrid.CubeBlocks.Count(c => c.Min.Z == maxZ);

                if (countMinX > countMinY && countMinX > countMinZ && countMinX > countMaxX && countMinX > countMaxY && countMinX > countMaxZ)
                {
                    xMirror = oddMirror ? Mirror.Odd : Mirror.EvenDown;
                    xAxis = minX;
                }
                else if (countMinY > countMinX && countMinY > countMinZ && countMinY > countMaxX && countMinY > countMaxY && countMinY > countMaxZ)
                {
                    yMirror = oddMirror ? Mirror.Odd : Mirror.EvenDown;
                    yAxis = minY;
                }
                else if (countMinZ > countMinX && countMinZ > countMinY && countMinZ > countMaxX && countMinZ > countMaxY && countMinZ > countMaxZ)
                {
                    zMirror = oddMirror ? Mirror.Odd : Mirror.EvenDown;
                    zAxis = minZ;
                }
                else if (countMaxX > countMinX && countMaxX > countMinY && countMaxX > countMinZ && countMaxX > countMaxY && countMaxX > countMaxZ)
                {
                    xMirror = oddMirror ? Mirror.Odd : Mirror.EvenUp;
                    xAxis = maxX;
                }
                else if (countMaxY > countMinX && countMaxY > countMinY && countMaxY > countMinZ && countMaxY > countMaxX && countMaxY > countMaxZ)
                {
                    yMirror = oddMirror ? Mirror.Odd : Mirror.EvenUp;
                    yAxis = maxY;
                }
                else if (countMaxZ > countMinX && countMaxZ > countMinY && countMaxZ > countMinZ && countMaxZ > countMaxX && countMaxZ > countMaxY)
                {
                    zMirror = oddMirror ? Mirror.Odd : Mirror.EvenUp;
                    zAxis = maxZ;
                }

                var cubes = MirrorCubes(this, false, xMirror, xAxis, yMirror, yAxis, zMirror, zAxis).ToArray();
                CubeGrid.CubeBlocks.AddRange(cubes);
                count += cubes.Length;
            }
            else
            {
                // Use the built in Mirror plane defined in game.
                if (CubeGrid.XMirroxPlane.HasValue)
                {
                    xMirror = CubeGrid.XMirroxOdd ? Mirror.EvenDown : Mirror.Odd; // Meaning is back to front? Or is it my reasoning?
                    xAxis = CubeGrid.XMirroxPlane.Value.X;
                    var cubes = MirrorCubes(this, true, xMirror, xAxis, Mirror.None, 0, Mirror.None, 0).ToArray();
                    CubeGrid.CubeBlocks.AddRange(cubes);
                    count += cubes.Length;

                    // TODO: mirror BlockGroups
                    // TODO: mirror ConveyorLines 
                }
                if (CubeGrid.YMirroxPlane.HasValue)
                {
                    yMirror = CubeGrid.YMirroxOdd ? Mirror.EvenDown : Mirror.Odd;
                    yAxis = CubeGrid.YMirroxPlane.Value.Y;
                    var cubes = MirrorCubes(this, true, Mirror.None, 0, yMirror, yAxis, Mirror.None, 0).ToArray();
                    CubeGrid.CubeBlocks.AddRange(cubes);
                    count += cubes.Length;

                    // TODO: mirror BlockGroups
                    // TODO: mirror ConveyorLines 
                }
                if (CubeGrid.ZMirroxPlane.HasValue)
                {
                    zMirror = CubeGrid.ZMirroxOdd ? Mirror.EvenUp : Mirror.Odd;
                    zAxis = CubeGrid.ZMirroxPlane.Value.Z;
                    var cubes = MirrorCubes(this, true, Mirror.None, 0, Mirror.None, 0, zMirror, zAxis).ToArray();
                    CubeGrid.CubeBlocks.AddRange(cubes);
                    count += cubes.Length;

                    // TODO: mirror BlockGroups
                    // TODO: mirror ConveyorLines 
                }
            }

            UpdateGeneralFromEntityBase();
            RaisePropertyChanged(() => BlockCount);
            return count > 0;
        }