private async Task<Result<string>> MigrateFileAndGetNewUrl(OldMediaData mediaData, Maybe<string> title, string codeNamePrefix = "")
        {
            var fileType = _fileHelper.GetFileType(mediaData.Extension);

            // Get Binary and Generate the assetMetadataWithSource
            var assetBinary = Maybe<byte[]>.None;

            if (mediaData.IsAttachment) {
                var attachmentBinary = await GetAttachmentBinary(mediaData.FileGuid);
                if (attachmentBinary.Length == 0) {
                    // try to get directly
                    attachmentBinary = await httpClient.GetByteArrayAsync($"https://direct.physicsclassroom.com/" + mediaData.PathLookup.Trim('/'));
                }
                if (attachmentBinary.Length > 0) {
                    assetBinary = attachmentBinary;
                }
            } else {
                // get file data stream, first check local
                var localPath = $"E:\\web\\dev.physicsclassroom.com-MediaFiles\\{mediaData.PathLookup.Replace("/", "\\")}";
                var fileInfo = new System.IO.FileInfo(localPath);
                if (fileInfo.Exists) {
                    var fileStream = File.Open(localPath, FileMode.Open, FileAccess.ReadWrite);
                    using (MemoryStream ms = new MemoryStream()) {
                        fileStream.CopyTo(ms);
                        assetBinary = ms.ToArray();
                    }
                    fileStream.Close();
                } else {
                    // try to get from url
                    var url = $"https://direct.physicsclassroom.com/" + mediaData.PathLookup.Trim('/');
                    HttpResponseMessage response = await httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, url));
                    if (!(response.Content.Headers.ContentType?.MediaType ?? "text/html").Equals("text/html", StringComparison.OrdinalIgnoreCase)) {
                        assetBinary = await httpClient.GetByteArrayAsync(url);
                    }
                }
            }

            if (!assetBinary.TryGetValue(out var assetBinaryVal)) {
                return Result.Failure<string>("No binary data found");
            }

            // Creates a metadata object that describes the uploaded asset
            var assetMetadata = new ContentItemAssetMetadata() {
                Extension = Path.GetExtension(mediaData.Extension),
                Identifier = Guid.NewGuid(), // the old Media Guid will go to the Content Item, not the Content Asset Item
                LastModified = mediaData.LastModified,
                Name = $"{Path.GetFileName(mediaData.FileName)}",
                Size = assetBinaryVal.Length
            };
            if (mediaData.ImageWidth.TryGetValue(out var width) && mediaData.ImageHeight.TryGetValue(out var height)) {
                assetMetadata.Width = width;
                assetMetadata.Height = height;
            }

            // Try writing to temp location file
            var tempPath = "E:\\web\\physicsclassroom.com-new\\Untracked-Other\\tempfiles\\" + mediaData.FileName;
            await File.WriteAllBytesAsync(tempPath, assetBinaryVal);
            var file = CMS.IO.FileInfo.New(tempPath);
            var fileSource = new ContentItemAssetFileSource(file.FullName, true);

            var assetMetadataWithSource = new ContentItemAssetMetadataWithSource(fileSource, assetMetadata);
            var workSpaceData = GetWorkspaceAndRootName(mediaData);
            var displayName = mediaData.FileName.Replace(mediaData.Extension, "").SplitAndRemoveEntries("-").Select(x => $"{x.Substring(0, 1).ToUpper()}{x.Substring(1)}").StringJoin(" ") + " " + mediaData.FileName;
            displayName = displayName.Length > 100 ? displayName.Substring(0, 100) : displayName;
            var contentItemName = ValidationHelper.GetCodeName($"{codeNamePrefix}{mediaData.FileName.Replace(mediaData.Extension, "")}-{mediaData.FileGuid.ToString().Split('-')[0]}");
            contentItemName = contentItemName.Length > 100 ? contentItemName.Substring(0, 100) : contentItemName;
            int contentItemID = 0;
            switch (fileType) {
                default:
                case FileTypes.Image:
                    var parametersImage = new CreateContentItemParameters(
                        contentTypeName: Generic.Image.CONTENT_TYPE_NAME,
                        name: contentItemName,
                        displayName: displayName,
                        languageName: "en",
                        workspaceName: workSpaceData.WorkspaceName) {
                        IsSecured = mediaData.IsAttachment && SecureNodeAliasPaths.Any(x => mediaData.PathLookup.IndexOf(x) > 0)
                    };

                    var descriptionFromAira = false;
                    var imageLongDescription = Maybe<string>.None;
                    var titleValue = mediaData.FileTitle.GetValueOrDefault(string.Empty);

                    if (!mediaData.FileDescription.TryGetValue(out var fileDescription)) {
                        // No description - need to generate and use
                        if ((await _openAIService.GenerateImageDescriptionAsync(assetBinaryVal, mediaData.MimeType)).TryGetValue(out var description)) {
                            fileDescription = description.ShortDescription;
                            imageLongDescription = description.LongDescription;
                            descriptionFromAira = true;
                        }
                    } else if (mediaData.FolderPath.Contains("chemtutorial", StringComparison.OrdinalIgnoreCase)) {
                        if ((await _openAIService.GenerateImageDescriptionAsync(assetBinaryVal, mediaData.MimeType)).TryGetValue(out var description)) {
                            // Use AI for long description for tom's tutorial images.
                            imageLongDescription = description.LongDescription;
                            descriptionFromAira = true;
                        }
                    } else if (mediaData.FolderPath.Contains("physics-tutorial", StringComparison.OrdinalIgnoreCase)) {
                        if (titleValue.Equals(fileDescription, StringComparison.OrdinalIgnoreCase)) {
                            // They match, so the title and File description are the same and there is no long description needed
                            imageLongDescription = Maybe.None;
                            fileDescription = titleValue;
                        } else {
                            // They don't match, so the "Title" is the description, and the description is the Long Description
                            imageLongDescription = fileDescription;
                            fileDescription = titleValue;
                        }
                    }

                    titleValue = titleValue.AsNullOrWhitespaceMaybe().GetValueOrDefault(parametersImage.DisplayName);
                    titleValue = titleValue.Length > 100 ? titleValue.Substring(0, 97)+"..." : titleValue;
                    var isAnimation = parametersImage.DisplayName.Contains("animation", StringComparison.OrdinalIgnoreCase) || titleValue.Contains("animation", StringComparison.OrdinalIgnoreCase) || (fileDescription ?? string.Empty).Contains("animation", StringComparison.OrdinalIgnoreCase);
                    ContentItemData itemDataImage = new ContentItemData(new Dictionary<string, object>{
                            { nameof(Image.ImageTitle), titleValue },
                            { nameof(Image.ImageDescription), fileDescription.GetValueOrDefault(string.Empty) },
                            { nameof(Image.ImageDescriptionLong), imageLongDescription.GetValueOrDefault(string.Empty) },
                            { nameof(Image.ImageDescriptionFromAira), descriptionFromAira },
                            { nameof(Image.ImageFile), assetMetadataWithSource },
                            { nameof(Image.ImageIsAnimation), isAnimation }
                        });

                    // Creates the content item in the database
                    try {
                        contentItemID = await _contentItemManager.Create(parametersImage, itemDataImage);
                    } catch (CodeNameNotUniqueException) {
                        // get existing
                        contentItemID = (await new DataQuery() { CustomQueryText = $"Select ContentItemID from CMS_ContentItem where ContentItemName = '{parametersImage.Name}'" }.GetDataContainerResultAsync()).First().GetValue("ContentItemID", 0); ;
                    }
                    break;
                case FileTypes.Audio:
                    var parametersAudio = new CreateContentItemParameters(
                        contentTypeName: Generic.Audio.CONTENT_TYPE_NAME,
                        name: contentItemName,
                        displayName: displayName,
                        languageName: "en",
                        workspaceName: workSpaceData.WorkspaceName) {
                        IsSecured = mediaData.IsAttachment && SecureNodeAliasPaths.Any(x => mediaData.PathLookup.IndexOf(x) > 0)
                    };

                    // Transcribe
                    var transcription = (await _openAIService.TranscribeAudio(assetBinaryVal, mediaData.FileName)).TryGetValue(out var transcriptionVal) ? transcriptionVal : Maybe<string>.None;

                    ContentItemData itemDataAudio = new ContentItemData(new Dictionary<string, object>{
                            { nameof(Audio.AudioTitle), parametersAudio.DisplayName },
                            { nameof(Audio.AudioDescription), mediaData.FileDescription.GetValueOrDefault(string.Empty) },
                            { nameof(Audio.AudioTranscript), transcription.GetValueOrDefault(string.Empty) },
                            { nameof(Audio.AudioFile), assetMetadataWithSource },
                        });

                    // Creates the content item in the database
                    try {
                        contentItemID = await _contentItemManager.Create(parametersAudio, itemDataAudio);
                    } catch (CodeNameNotUniqueException) {
                        // get existing
                        contentItemID = (await new DataQuery() { CustomQueryText = $"Select ContentItemID from CMS_ContentItem where ContentItemName = '{parametersAudio.Name}'" }.GetDataContainerResultAsync()).First().GetValue("ContentItemID", 0); ;
                    }
                    break;
                case FileTypes.Video:
                    var parametersVideo = new CreateContentItemParameters(
                        contentTypeName: Generic.Video.CONTENT_TYPE_NAME,
                        name: contentItemName,
                        displayName: displayName,
                        languageName: "en",
                        workspaceName: workSpaceData.WorkspaceName) {
                        IsSecured = mediaData.IsAttachment && SecureNodeAliasPaths.Any(x => mediaData.PathLookup.IndexOf(x) > 0)
                    };

                    ContentItemData itemDataVideo = new ContentItemData(new Dictionary<string, object>{
                            { nameof(Video.VideoTitle), parametersVideo.DisplayName },
                            { nameof(Video.VideoDescription), mediaData.FileDescription.GetValueOrDefault(string.Empty) },
                            { nameof(Video.VideoFile), assetMetadataWithSource },
                        });

                    // Creates the content item in the database
                    try {
                        contentItemID = await _contentItemManager.Create(parametersVideo, itemDataVideo);
                    } catch (CodeNameNotUniqueException) {
                        // get existing
                        contentItemID = (await new DataQuery() { CustomQueryText = $"Select ContentItemID from CMS_ContentItem where ContentItemName = '{parametersVideo.Name}'" }.GetDataContainerResultAsync()).First().GetValue("ContentItemID", 0); ;
                    }
                    break;
                case FileTypes.File:
                     var parametersFile = new CreateContentItemParameters(
                        contentTypeName: Generic.File.CONTENT_TYPE_NAME,
                        name: ValidationHelper.GetCodeName($"{codeNamePrefix}{mediaData.FileName.Replace(mediaData.Extension, "")}-{mediaData.FileGuid.ToString().Split('-')[0]}"),
                        displayName: mediaData.FileTitle.GetValueOrDefault(title.GetValueOrDefault(mediaData.FileName)),
                        languageName: "en",
                        workspaceName: workSpaceData.WorkspaceName) {
                        IsSecured = mediaData.IsAttachment && SecureNodeAliasPaths.Any(x => mediaData.PathLookup.IndexOf(x) > 0),
                    };

                    ContentItemData itemDataFile = new ContentItemData(new Dictionary<string, object>{
                            { nameof(Generic.File.FileTitle), parametersFile.DisplayName },
                            { nameof(Generic.File.FileDescription), mediaData.FileDescription.GetValueOrDefault(string.Empty) },
                            { nameof(Generic.File.FileFile), assetMetadataWithSource },
                        });

                    // Creates the content item in the database
                    try {
                        contentItemID = await _contentItemManager.Create(parametersFile, itemDataFile);
                    } catch (CodeNameNotUniqueException ex) {
                        // get existing
                        contentItemID = (await new DataQuery() { CustomQueryText = $"Select ContentItemID from CMS_ContentItem where ContentItemName = '{parametersFile.Name}'" }.GetDataContainerResultAsync()).First().GetValue("ContentItemID", 0); ;
                    }
                    break;
            }

            // delete temp file
            File.Delete(tempPath);

            if (contentItemID > 0) {
                // set guid, can't seem to figure out how to adjust aside from SQL, and then manually moving files *bleh*

                // get current GUID so we can pinpoint the file
                var currentQuery = $"Select ContentItemGUID from CMS_ContentItem where ContentItemID = {contentItemID}";
                var oldGuid = (await new DataQuery() { CustomQueryText = currentQuery }.GetDataContainerResultAsync()).First().GetValue<Guid>("ContentItemGUID", Guid.Empty);

                var fileGuidQuery = $@"select JSON_VALUE(FileData, '$.Identifier') as ID from (
select FileFile as FileData from Generic_File GI inner join CMS_ContentItemCommonData CD on CD.ContentItemCommonDataID = GI.ContentItemDataCommonDataID where ContentItemCommonDataContentItemID = {contentItemID}
union all
select AudioFile as FileData from Generic_Audio GI inner join CMS_ContentItemCommonData CD on CD.ContentItemCommonDataID = GI.ContentItemDataCommonDataID where ContentItemCommonDataContentItemID = {contentItemID}
UNION ALL
select ImageFile as FileData from Generic_Image GI inner join CMS_ContentItemCommonData CD on CD.ContentItemCommonDataID = GI.ContentItemDataCommonDataID where ContentItemCommonDataContentItemID = {contentItemID}
UNION ALL
select VideoFile as FileData from Generic_Video GI inner join CMS_ContentItemCommonData CD on CD.ContentItemCommonDataID = GI.ContentItemDataCommonDataID where ContentItemCommonDataContentItemID = {contentItemID}
) item";
                // TODO: Add in the HTML Module Files to this as well so it will work
                var fileGuid = (await new DataQuery() { CustomQueryText = fileGuidQuery }.GetDataContainerResultAsync()).First().GetValue("ID", string.Empty).ToString().ToLower();

                var oldGuidPath = oldGuid.ToString().Substring(0, 2).ToLower() + "/" + oldGuid.ToString().ToLower();
                var sourceFolder = "assets/contentitems/" + oldGuidPath;

                var newGuidPath = mediaData.FileGuid.ToString().Substring(0, 2).ToLower() + "/" + mediaData.FileGuid.ToString().ToLower();
                var targetFolder = sourceFolder.Replace(oldGuidPath, newGuidPath);


                var blobServiceClient = new BlobServiceClient("DefaultEndpointsProtocol=https;AccountName=XXXREPLACEMEXXX;AccountKey=XXXREPLACEMEXXX;EndpointSuffix=core.windows.net");
                var containerClient = blobServiceClient.GetBlobContainerClient("production");
                var blobs = containerClient.GetBlobs(BlobTraits.None, BlobStates.None, sourceFolder);
                foreach (var blob in blobs) {
                    var targetBlobClient = containerClient.GetBlobClient($"{blob.Name.Replace(oldGuidPath, newGuidPath)}");
                    var blobUri = new Uri($"{containerClient.Uri}/{blob.Name}");
                    var copyOp = await targetBlobClient.StartCopyFromUriAsync(blobUri);
                    await copyOp.WaitForCompletionAsync();
                    containerClient.DeleteBlob(blob.Name);
                }

                var updateQuery = $"update CMS_ContentItem set ContentItemGUID = '{mediaData.FileGuid}' where ContentItemID = {contentItemID}";
                await new DataQuery() { CustomQueryText = updateQuery }.ExecuteNonQueryAsync();

                // Move to proper Folder
                var fileFolderId = await GetOrCreateFolder(mediaData);
                await _contentFolderManager.MoveItems(fileFolderId, [contentItemID]);

                // Publish it
                await _contentItemManager.TryPublish(contentItemID, "en");

                // Return new URL
                return $"/getcontentasset/{mediaData.FileGuid}/{_fileHelper.GetFileContentAssetItemFieldGuid(mediaData.Extension)}/{HttpUtility.UrlEncode(mediaData.FileName.ToLower())}";
            }

            return Result.Failure<string>("No Content Item Created");
        }