param(
    [string]$VideoRoot = 'D:\视频库',
    [string]$BaseUrl = 'http://192.168.1.101:9000',
    [string]$OutputPath = '',
    [string]$AdminUsername = 'admin',
    [string]$AdminPassword = 'admin123',
    [string]$DefaultUserPassword = 'Pass@123456',
    [string]$RedisHost = '192.168.1.101',
    [int]$RedisPort = 6379,
    [string]$RedisPassword = '',
    [switch]$ReuseExistingUsers
)

$ErrorActionPreference = 'Stop'

if ([string]::IsNullOrWhiteSpace($OutputPath)) {
    $OutputPath = Join-Path $PSScriptRoot 'VIDEO_IMPORT_RESULTS.json'
}

function New-OrderedMap {
    return [ordered]@{}
}

function ConvertTo-PlainObject {
    param([object]$Value)

    if ($null -eq $Value) {
        return $null
    }

    if ($Value -is [System.Collections.IDictionary]) {
        $result = [ordered]@{}
        foreach ($key in $Value.Keys) {
            $result[$key] = ConvertTo-PlainObject -Value $Value[$key]
        }
        return $result
    }

    if ($Value -is [System.Collections.IEnumerable] -and -not ($Value -is [string])) {
        $items = @()
        foreach ($item in $Value) {
            $items += ,(ConvertTo-PlainObject -Value $item)
        }
        return $items
    }

    $type = $Value.GetType()
    if ($type.FullName -like 'System.Management.Automation.PSCustomObject' -or
        ($type.Namespace -and $type.Namespace -notlike 'System*')) {
        $result = [ordered]@{}
        foreach ($prop in $Value.PSObject.Properties) {
            $result[$prop.Name] = ConvertTo-PlainObject -Value $prop.Value
        }
        return $result
    }

    return $Value
}

function Save-Report {
    param([hashtable]$Report)

    $plain = ConvertTo-PlainObject -Value $Report
    $plain | ConvertTo-Json -Depth 20 | Set-Content -Path $OutputPath -Encoding utf8BOM
}

function Invoke-JsonApi {
    param(
        [Parameter(Mandatory = $true)][string]$Method,
        [Parameter(Mandatory = $true)][string]$Url,
        [hashtable]$Headers = @{},
        $Body = $null,
        [int]$TimeoutSec = 180
    )

    $params = @{
        Method = $Method
        Uri = $Url
        Headers = $Headers
        UseBasicParsing = $true
        SkipHttpErrorCheck = $true
        TimeoutSec = $TimeoutSec
    }

    if ($null -ne $Body) {
        $params.ContentType = 'application/json'
        if ($Body -is [string]) {
            $params.Body = $Body
        } else {
            $params.Body = ($Body | ConvertTo-Json -Depth 20)
        }
    }

    try {
        $response = Invoke-WebRequest @params
        $json = $null
        if ($response.Content) {
            try {
                $json = $response.Content | ConvertFrom-Json -Depth 50
            } catch {
                $json = $null
            }
        }

        return [pscustomobject]@{
            HttpStatus = [int]$response.StatusCode
            Json = $json
            Raw = $response.Content
        }
    } catch {
        return [pscustomobject]@{
            HttpStatus = -1
            Json = $null
            Raw = $_.Exception.Message
        }
    }
}

function Invoke-UploadApi {
    param(
        [Parameter(Mandatory = $true)][string]$Url,
        [Parameter(Mandatory = $true)][string]$FilePath,
        [hashtable]$Headers = @{},
        [int]$TimeoutSec = 7200
    )

    $handler = $null
    $httpClient = $null
    $fileStream = $null
    try {
        $handler = New-Object System.Net.Http.HttpClientHandler
        $httpClient = New-Object System.Net.Http.HttpClient($handler)
        $httpClient.Timeout = [TimeSpan]::FromSeconds($TimeoutSec)

        foreach ($headerKey in $Headers.Keys) {
            [void]$httpClient.DefaultRequestHeaders.TryAddWithoutValidation($headerKey, [string]$Headers[$headerKey])
        }

        $multipart = New-Object System.Net.Http.MultipartFormDataContent
        $fileStream = [System.IO.File]::OpenRead($FilePath)
        $fileContent = New-Object System.Net.Http.StreamContent($fileStream)

        $mimeType = switch ([System.IO.Path]::GetExtension($FilePath).ToLowerInvariant()) {
            '.mp4' { 'video/mp4' }
            '.mov' { 'video/quicktime' }
            '.mkv' { 'video/x-matroska' }
            '.avi' { 'video/x-msvideo' }
            '.webm' { 'video/webm' }
            '.m4v' { 'video/x-m4v' }
            '.flv' { 'video/x-flv' }
            default { 'video/mp4' }
        }
        $fileContent.Headers.ContentType = [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse($mimeType)
        $multipart.Add($fileContent, 'file', [System.IO.Path]::GetFileName($FilePath))

        $response = $httpClient.PostAsync($Url, $multipart).GetAwaiter().GetResult()
        $raw = $response.Content.ReadAsStringAsync().GetAwaiter().GetResult()
        $json = $null
        if ($raw) {
            try {
                $json = $raw | ConvertFrom-Json -Depth 50
            } catch {
                $json = $null
            }
        }

        return [pscustomobject]@{
            HttpStatus = [int]$response.StatusCode
            Json = $json
            Raw = $raw
        }
    } catch {
        return [pscustomobject]@{
            HttpStatus = -1
            Json = $null
            Raw = $_.Exception.Message
        }
    } finally {
        if ($fileStream) { $fileStream.Dispose() }
        if ($httpClient) { $httpClient.Dispose() }
        if ($handler) { $handler.Dispose() }
    }
}

function Read-DotEnv {
    param([string]$Path)

    $map = @{}
    if (-not (Test-Path -LiteralPath $Path)) {
        return $map
    }

    foreach ($line in Get-Content -LiteralPath $Path) {
        if ([string]::IsNullOrWhiteSpace($line) -or $line.TrimStart().StartsWith('#')) {
            continue
        }
        $parts = $line -split '=', 2
        if ($parts.Count -eq 2) {
            $map[$parts[0].Trim()] = $parts[1].Trim()
        }
    }
    return $map
}

function Read-RedisLine {
    param([System.IO.Stream]$Stream)

    $bytes = New-Object System.Collections.Generic.List[byte]
    while ($true) {
        $b = $Stream.ReadByte()
        if ($b -lt 0) {
            throw 'Redis 连接已关闭'
        }
        if ($b -eq 13) {
            $next = $Stream.ReadByte()
            if ($next -ne 10) {
                throw 'Redis 响应格式错误'
            }
            break
        }
        $bytes.Add([byte]$b)
    }
    return [System.Text.Encoding]::UTF8.GetString($bytes.ToArray())
}

function Send-RedisCommand {
    param(
        [System.IO.Stream]$Stream,
        [string[]]$RedisArgs
    )

    $builder = New-Object System.Text.StringBuilder
    [void]$builder.Append("*$($RedisArgs.Count)`r`n")
    foreach ($arg in $RedisArgs) {
        $bytes = [System.Text.Encoding]::UTF8.GetBytes($arg)
        [void]$builder.Append("$" + $bytes.Length + "`r`n")
        [void]$builder.Append($arg + "`r`n")
    }

    $payload = [System.Text.Encoding]::UTF8.GetBytes($builder.ToString())
    $Stream.Write($payload, 0, $payload.Length)
    $Stream.Flush()

    $prefix = [char]$Stream.ReadByte()
    switch ($prefix) {
        '+' { return Read-RedisLine -Stream $Stream }
        '-' { throw "Redis 错误: $(Read-RedisLine -Stream $Stream)" }
        ':' { return [int64](Read-RedisLine -Stream $Stream) }
        '$' {
            $length = [int](Read-RedisLine -Stream $Stream)
            if ($length -lt 0) {
                return $null
            }
            $buffer = New-Object byte[] $length
            $offset = 0
            while ($offset -lt $length) {
                $read = $Stream.Read($buffer, $offset, $length - $offset)
                if ($read -le 0) {
                    throw 'Redis bulk string 读取失败'
                }
                $offset += $read
            }
            $null = Read-RedisLine -Stream $Stream
            return [System.Text.Encoding]::UTF8.GetString($buffer)
        }
        '*' {
            $count = [int](Read-RedisLine -Stream $Stream)
            $items = @()
            for ($i = 0; $i -lt $count; $i++) {
                $nestedPrefix = [char]$Stream.ReadByte()
                if ($nestedPrefix -ne '$') {
                    throw "暂不支持的 Redis 数组子类型: $nestedPrefix"
                }
                $len = [int](Read-RedisLine -Stream $Stream)
                if ($len -lt 0) {
                    $items += $null
                    continue
                }
                $buf = New-Object byte[] $len
                $offset = 0
                while ($offset -lt $len) {
                    $read = $Stream.Read($buf, $offset, $len - $offset)
                    if ($read -le 0) {
                        throw 'Redis 数组元素读取失败'
                    }
                    $offset += $read
                }
                $null = Read-RedisLine -Stream $Stream
                $items += [System.Text.Encoding]::UTF8.GetString($buf)
            }
            return $items
        }
        default { throw "未知 Redis 响应前缀: $prefix" }
    }
}

function Get-AvailableRedisPasswords {
    $candidates = New-Object System.Collections.Generic.List[string]
    foreach ($candidate in @(
        $RedisPassword,
        'redis_HA_Cluster_2024',
        'replace-with-strong-redis-password',
        'redis_EsJ8FX'
    )) {
        if (-not [string]::IsNullOrWhiteSpace($candidate) -and -not $candidates.Contains($candidate)) {
            $candidates.Add($candidate)
        }
    }
    return $candidates
}

function Get-RedisValue {
    param(
        [Parameter(Mandatory = $true)][string]$Key,
        [int]$RedisDbIndex = 0
    )

    $passwords = Get-AvailableRedisPasswords
    $lastError = $null

    foreach ($passwordCandidate in $passwords) {
        $tcp = $null
        try {
            $tcp = [System.Net.Sockets.TcpClient]::new()
            $tcp.ReceiveTimeout = 5000
            $tcp.SendTimeout = 5000
            $tcp.Connect($RedisHost, $RedisPort)
            $stream = $tcp.GetStream()

            [void](Send-RedisCommand -Stream $stream -RedisArgs @('AUTH', $passwordCandidate))
            if ($RedisDbIndex -gt 0) {
                [void](Send-RedisCommand -Stream $stream -RedisArgs @('SELECT', $RedisDbIndex.ToString()))
            }
            $value = Send-RedisCommand -Stream $stream -RedisArgs @('GET', $Key)
            $tcp.Close()
            return $value
        } catch {
            $lastError = $_.Exception.Message
            if ($tcp) {
                $tcp.Close()
            }
        }
    }

    throw "读取 Redis 键失败: $Key；host=${RedisHost}:$RedisPort；lastError=$lastError"
}

function Get-CaptchaCode {
    param(
        [Parameter(Mandatory = $true)][string]$CaptchaUrl,
        [Parameter(Mandatory = $true)][string]$RedisKeyPrefix,
        [int]$RedisDb = 0
    )

    $captchaResp = Invoke-JsonApi -Method GET -Url $CaptchaUrl
    if ($captchaResp.HttpStatus -ne 200 -or -not $captchaResp.Json -or -not $captchaResp.Json.data) {
        throw "获取验证码失败: $($captchaResp.Raw)"
    }

    $captchaKey = [string]$captchaResp.Json.data.captchaKey
    $code = Get-RedisValue -Key "$RedisKeyPrefix$captchaKey" -RedisDbIndex $RedisDb

    return [pscustomobject]@{
        CaptchaKey = $captchaKey
        CaptchaCode = ([string]$code).Trim('"').Trim()
    }
}

function Ensure-ApiSuccess {
    param(
        [Parameter(Mandatory = $true)]$Response,
        [Parameter(Mandatory = $true)][string]$Action
    )

    if ($Response.HttpStatus -ne 200) {
        throw "$Action 失败，HTTP=$($Response.HttpStatus)，响应=$($Response.Raw)"
    }

    if (-not $Response.Json) {
        throw "$Action 失败，响应不是 JSON: $($Response.Raw)"
    }

    if ($Response.Json.code -ne 200) {
        throw "$Action 失败，API code=$($Response.Json.code)，message=$($Response.Json.message)"
    }
}

function New-RandomPhone {
    $digits = -join ((0..9) | Get-Random -Count 9)
    return "13$digits"
}

function New-Username {
    param(
        [string]$CategoryName,
        [int]$Index
    )

    $stamp = (Get-Date).ToString('MMddHHmm')
    return ("u{0}{1:D2}" -f $stamp, $Index)
}

function Normalize-VideoTitle {
    param([string]$FileNameWithoutExtension)

    $title = $FileNameWithoutExtension.Trim()
    if ($title.Length -lt 5) {
        $title = ($title + ' 视频素材').Substring(0, [Math]::Min(($title + ' 视频素材').Length, 100))
    }
    if ($title.Length -gt 100) {
        $title = $title.Substring(0, 100)
    }
    return $title
}

function Get-UserSession {
    param(
        [string]$Username,
        [string]$Password
    )

    $captcha = Get-CaptchaCode -CaptchaUrl "$BaseUrl/auth/captcha" -RedisKeyPrefix 'captcha:' -RedisDb 0
    $loginResp = Invoke-JsonApi -Method POST -Url "$BaseUrl/auth/login" -Body @{
        username = $Username
        password = $Password
        captcha = $captcha.CaptchaCode
        captchaKey = $captcha.CaptchaKey
    }
    Ensure-ApiSuccess -Response $loginResp -Action "用户登录($Username)"

    $accessToken = [string]$loginResp.Json.data.accessToken
    $headers = @{ Authorization = "Bearer $accessToken" }
    $currentResp = Invoke-JsonApi -Method GET -Url "$BaseUrl/auth/current" -Headers $headers
    Ensure-ApiSuccess -Response $currentResp -Action "读取当前用户($Username)"

    return [pscustomobject]@{
        Username = $Username
        Password = $Password
        UserId = [long]$currentResp.Json.data.id
        Headers = $headers
        AccessToken = $accessToken
    }
}

function Get-ReusedUsersByCategory {
    param([string]$ReportPath)

    if (-not (Test-Path -LiteralPath $ReportPath)) {
        throw "复用用户失败，报告文件不存在: $ReportPath"
    }

    $json = Get-Content -LiteralPath $ReportPath -Raw | ConvertFrom-Json -Depth 50
    $map = @{}
    foreach ($entry in @($json.users)) {
        $categoryName = [string]$entry.categoryName
        if (-not $map.ContainsKey($categoryName)) {
            $map[$categoryName] = New-Object System.Collections.Generic.List[object]
        }
        $session = Get-UserSession -Username ([string]$entry.username) -Password ([string]$entry.password)
        $session | Add-Member -NotePropertyName Nickname -NotePropertyValue ([string]$entry.nickname) -Force
        $session | Add-Member -NotePropertyName CategoryName -NotePropertyValue $categoryName -Force
        $map[$categoryName].Add($session)
    }
    return $map
}

function Register-ImportUser {
    param(
        [string]$CategoryName,
        [int]$UserIndex,
        [string]$Nickname
    )

    $username = New-Username -CategoryName $CategoryName -Index $UserIndex
    $phone = New-RandomPhone
    $email = "$username@example.com"
    $captcha = Get-CaptchaCode -CaptchaUrl "$BaseUrl/auth/captcha" -RedisKeyPrefix 'captcha:' -RedisDb 0

    $registerResp = Invoke-JsonApi -Method POST -Url "$BaseUrl/auth/register" -Body @{
        username = $username
        password = $DefaultUserPassword
        confirmPassword = $DefaultUserPassword
        email = $email
        phone = $phone
        captcha = $captcha.CaptchaCode
        captchaKey = $captcha.CaptchaKey
    }
    Ensure-ApiSuccess -Response $registerResp -Action "注册用户($username)"

    $session = Get-UserSession -Username $username -Password $DefaultUserPassword

    $profileResp = Invoke-JsonApi -Method PUT -Url "$BaseUrl/user/profile" -Headers $session.Headers -Body @{
        nickname = $Nickname
        signature = "批量导入账号 - $CategoryName"
        region = '南京'
        gender = 0
    }
    Ensure-ApiSuccess -Response $profileResp -Action "更新资料($username)"

    $session | Add-Member -NotePropertyName Nickname -NotePropertyValue $Nickname
    $session | Add-Member -NotePropertyName CategoryName -NotePropertyValue $CategoryName
    return $session
}

function Get-AdminSession {
    $captcha = Get-CaptchaCode -CaptchaUrl "$BaseUrl/admin/auth/captcha" -RedisKeyPrefix 'admin:captcha:' -RedisDb 5
    $loginResp = Invoke-JsonApi -Method POST -Url "$BaseUrl/admin/auth/login" -Body @{
        username = $AdminUsername
        password = $AdminPassword
        captcha = $captcha.CaptchaCode
        captchaKey = $captcha.CaptchaKey
    }
    Ensure-ApiSuccess -Response $loginResp -Action '管理员登录'

    $token = [string]$loginResp.Json.data.token
    $headers = @{ Authorization = "Bearer $token" }
    $infoResp = Invoke-JsonApi -Method GET -Url "$BaseUrl/admin/auth/info" -Headers $headers
    Ensure-ApiSuccess -Response $infoResp -Action '获取管理员信息'

    return [pscustomobject]@{
        Headers = $headers
        AdminId = [long]$infoResp.Json.data.id
        Username = $AdminUsername
    }
}

function Get-CategoryMap {
    $resp = Invoke-JsonApi -Method GET -Url "$BaseUrl/content/category/list"
    Ensure-ApiSuccess -Response $resp -Action '读取分类列表'

    $map = @{}
    foreach ($item in @($resp.Json.data)) {
        $map[[string]$item.name] = $item
    }
    return $map
}

function Get-VideoFilesForFolder {
    param([string]$FolderPath)

    $extensions = @('.mp4', '.mov', '.mkv', '.avi', '.flv', '.webm', '.m4v')
    return @(Get-ChildItem -LiteralPath $FolderPath -File |
        Where-Object { $extensions -contains $_.Extension.ToLowerInvariant() } |
        Sort-Object Name)
}

$report = [ordered]@{
    generatedAt = (Get-Date).ToString('s')
    baseUrl = $BaseUrl
    videoRoot = $VideoRoot
    outputPath = $OutputPath
    userPassword = $DefaultUserPassword
    summary = [ordered]@{
        categoryCount = 0
        expectedUsers = 0
        createdUsers = 0
        expectedVideos = 0
        uploadedVideos = 0
        reviewedVideos = 0
        failedVideos = 0
    }
    categories = @()
    users = @()
    errors = @()
}

if (-not (Test-Path -LiteralPath $VideoRoot)) {
    throw "视频根目录不存在: $VideoRoot"
}

$categoryFolders = @(Get-ChildItem -LiteralPath $VideoRoot -Directory | Sort-Object Name)
if ($categoryFolders.Count -ne 5) {
    throw "期望在 $VideoRoot 下找到 5 个分类目录，实际找到 $($categoryFolders.Count) 个"
}

$categoryMap = Get-CategoryMap
$adminSession = Get-AdminSession
$reusedUsersByCategory = $null
if ($ReuseExistingUsers) {
    $reusedUsersByCategory = Get-ReusedUsersByCategory -ReportPath $OutputPath
    $report.users = @()
    foreach ($categoryUsers in $reusedUsersByCategory.Values) {
        foreach ($user in $categoryUsers) {
            $report.users += [ordered]@{
                categoryName = $user.CategoryName
                username = $user.Username
                nickname = $user.Nickname
                password = $user.Password
                userId = $user.UserId
                assignedVideoCount = $null
            }
        }
    }
    $report.summary.createdUsers = $report.users.Count
}

Save-Report -Report $report

$report.summary.categoryCount = $categoryFolders.Count
$report.summary.expectedUsers = $categoryFolders.Count * 2
$report.summary.expectedVideos = $categoryFolders.Count * 5
$report.summary.uploadedVideos = 0
$report.summary.reviewedVideos = 0
$report.summary.failedVideos = 0
$report.categories = @()
$report.errors = @()

$globalUserIndex = 1

foreach ($folder in $categoryFolders) {
    $categoryName = $folder.Name
    if (-not $categoryMap.ContainsKey($categoryName)) {
        throw "平台中未找到分类: $categoryName"
    }

    $videoFiles = Get-VideoFilesForFolder -FolderPath $folder.FullName
    if ($videoFiles.Count -ne 5) {
        throw "分类 [$categoryName] 期望有 5 个视频，实际找到 $($videoFiles.Count) 个"
    }

    $platformCategory = $categoryMap[$categoryName]
    $categoryReport = [ordered]@{
        categoryName = $categoryName
        categoryId = [long]$platformCategory.id
        folderPath = $folder.FullName
        userAssignments = @()
    }

    $report.categories += $categoryReport
    Save-Report -Report $report

    $assignmentSpecs = @(
        @{ UserLabel = 'A'; VideoIndexes = @(0, 1); VideoCount = 2 },
        @{ UserLabel = 'B'; VideoIndexes = @(2, 3, 4); VideoCount = 3 }
    )

    $reusedCategoryUsers = $null
    if ($ReuseExistingUsers) {
        if (-not $reusedUsersByCategory.ContainsKey($categoryName) -or $reusedUsersByCategory[$categoryName].Count -ne 2) {
            throw "分类 [$categoryName] 没有可复用的 2 个用户"
        }
        $reusedCategoryUsers = $reusedUsersByCategory[$categoryName].ToArray()
    }

    $assignmentIndex = 0
    foreach ($assignmentSpec in $assignmentSpecs) {
        if ($ReuseExistingUsers) {
            $userSession = $reusedCategoryUsers[$assignmentIndex]
            $nickname = $userSession.Nickname
        } else {
            $nickname = "$categoryName-导入用户$($assignmentSpec.UserLabel)"
            $userSession = Register-ImportUser -CategoryName $categoryName -UserIndex $globalUserIndex -Nickname $nickname
            $globalUserIndex++

            $report.summary.createdUsers++
            $report.users += [ordered]@{
                categoryName = $categoryName
                username = $userSession.Username
                nickname = $nickname
                password = $userSession.Password
                userId = $userSession.UserId
                assignedVideoCount = $assignmentSpec.VideoCount
            }
        }

        $userAssignmentReport = [ordered]@{
            userId = $userSession.UserId
            username = $userSession.Username
            nickname = $nickname
            assignedVideoCount = $assignmentSpec.VideoCount
            videos = @()
        }

        foreach ($videoIndex in $assignmentSpec.VideoIndexes) {
            $file = $videoFiles[$videoIndex]
            $videoReport = [ordered]@{
                sourceFile = $file.FullName
                fileName = $file.Name
                ownerUserId = $userSession.UserId
                ownerUsername = $userSession.Username
                status = 'processing'
                upload = $null
                create = $null
                review = $null
                publicCheck = $null
                error = $null
            }

            try {
                $uploadResp = Invoke-UploadApi -Url "$BaseUrl/content/video/upload" -FilePath $file.FullName -Headers $userSession.Headers
                Ensure-ApiSuccess -Response $uploadResp -Action "上传视频($($file.Name))"

                $videoTitle = Normalize-VideoTitle -FileNameWithoutExtension $file.BaseName
                $createResp = Invoke-JsonApi -Method POST -Url "$BaseUrl/content/video" -Headers $userSession.Headers -Body @{
                    title = $videoTitle
                    description = "批量导入视频；分类：$categoryName；源文件：$($file.Name)"
                    categoryId = [long]$platformCategory.id
                    tagIds = @()
                    coverUrl = $uploadResp.Json.data.coverUrl
                    videoUrl = $uploadResp.Json.data.videoUrl
                    duration = $uploadResp.Json.data.duration
                    width = $uploadResp.Json.data.width
                    height = $uploadResp.Json.data.height
                    format = $uploadResp.Json.data.format
                    size = $uploadResp.Json.data.size
                }
                Ensure-ApiSuccess -Response $createResp -Action "创建视频($($file.Name))"

                $videoId = [long]$createResp.Json.data
                $reviewResp = Invoke-JsonApi -Method POST -Url "$BaseUrl/admin/platform/content/video/review/$videoId?status=1&reason=bulk-import" -Headers $adminSession.Headers
                Ensure-ApiSuccess -Response $reviewResp -Action "审核视频($videoId)"

                $publicCheckResp = Invoke-JsonApi -Method GET -Url "$BaseUrl/content/video/public/$videoId"
                Ensure-ApiSuccess -Response $publicCheckResp -Action "校验公开视频($videoId)"

                $videoReport.status = 'completed'
                $videoReport.upload = [ordered]@{
                    videoUrl = $uploadResp.Json.data.videoUrl
                    coverUrl = $uploadResp.Json.data.coverUrl
                    duration = $uploadResp.Json.data.duration
                    width = $uploadResp.Json.data.width
                    height = $uploadResp.Json.data.height
                    format = $uploadResp.Json.data.format
                    size = $uploadResp.Json.data.size
                }
                $videoReport.create = [ordered]@{
                    videoId = $videoId
                    title = $videoTitle
                    categoryId = [long]$platformCategory.id
                }
                $videoReport.review = [ordered]@{
                    status = 1
                    reviewerAdminId = $adminSession.AdminId
                }
                $videoReport.publicCheck = [ordered]@{
                    videoId = $videoId
                    apiCode = $publicCheckResp.Json.code
                }

                $report.summary.uploadedVideos++
                $report.summary.reviewedVideos++
            } catch {
                $videoReport.status = 'failed'
                $videoReport.error = $_.Exception.Message
                $report.summary.failedVideos++
                $report.errors += "[$categoryName][$($userSession.Username)][$($file.Name)] $($_.Exception.Message)"
            }

            $userAssignmentReport.videos += $videoReport
            Save-Report -Report $report
        }

        $categoryReport.userAssignments += $userAssignmentReport
        $assignmentIndex++
        Save-Report -Report $report
    }
    Save-Report -Report $report
}

$report.generatedAt = (Get-Date).ToString('s')
Save-Report -Report $report

$report | ConvertTo-Json -Depth 20