import { debug, debugDir } from '@socketsecurity/lib-stable/debug/output'

import { getDefaultLogger } from '@socketsecurity/lib-stable/logger/default'

import { getDefaultSpinner } from '@socketsecurity/lib-stable/spinner/default'

import { formatErrorWithDetail } from '../../util/error/errors.mjs'

import {

handleApiCallNoSpinner,

queryApiSafeText,

} from '../../util/socket/api.mjs'

import { setupSdk } from '../../util/socket/sdk.mjs'

import type { CResult } from '../../types.mts'

import type { SocketArtifact } from '../../util/alert/artifact.mts'

import type { SetupSdkOptions } from '../../util/socket/sdk.mjs'

import type { SocketSdkSuccessResult } from '@socketsecurity/sdk-stable'

const logger = getDefaultLogger()

export type FetchScanData = {

includeLicensePolicy?: boolean | undefined

sdkOpts?: SetupSdkOptions | undefined

}

/**

* This fetches all the relevant pieces of data to generate a report, given a

* full scan ID.

*/

export async function fetchScanData(

orgSlug: string,

scanId: string,

options?: FetchScanData | undefined,

): Promise<

CResult<{

scan: SocketArtifact[]

securityPolicy: SocketSdkSuccessResult<'getOrgSecurityPolicy'>['data']

}>

> {

const { includeLicensePolicy, sdkOpts } = {

__proto__: null,

...options,

} as FetchScanData

const spinner = getDefaultSpinner()

const sockSdkCResult = await setupSdk(sdkOpts)

if (!sockSdkCResult.ok) {

return sockSdkCResult

}

const sockSdk = sockSdkCResult.data

let policyStatus = 'requested…'

let scanStatus = 'requested…'

let finishedFetching = false

function updateScan(status: string) {

scanStatus = status

updateProgress()

}

function updatePolicy(status: string) {

policyStatus = status

updateProgress()

}

function updateProgress() {

if (finishedFetching) {

spinner.stop()

logger.info(

`Scan result: ${scanStatus}. Security policy: ${policyStatus}.`,

)

} else {

spinner.start(

`Scan result: ${scanStatus}. Security policy: ${policyStatus}.`,

)

}

}

async function fetchScanResult(): Promise<CResult<SocketArtifact[]>> {

const result = await queryApiSafeText(

`orgs/${orgSlug}/full-scans/${encodeURIComponent(scanId)}${includeLicensePolicy ? '?include_license_details=true' : ''}`,

)

updateScan('response received')

if (!result.ok) {

return result

}

const ndJsonString = result.data

// This is nd-json; each line is a json object.

const lines = ndJsonString.split(/\r?\n/).filter(Boolean)

const data: SocketArtifact[] = []

for (let i = 0, { length } = lines; i < length; i += 1) {

const line = lines[i]!

try {

data.push(JSON.parse(line))

} catch (e) {

debug('Failed to parse report data line as JSON')

debugDir({ error: e, line })

updateScan('received invalid JSON response')

return {

__proto__: null,

ok: false,

message: 'Invalid Socket API response',

cause:

'The Socket API responded with at least one line that was not valid JSON. Please report if this persists.',

}

}

}

updateScan('success')

return { __proto__: null, ok: true, data }

}

async function fetchSecurityPolicy(): Promise<

CResult<SocketSdkSuccessResult<'getOrgSecurityPolicy'>['data']>

> {

const result = (await handleApiCallNoSpinner(

sockSdk.getOrgSecurityPolicy(orgSlug),

'GetOrgSecurityPolicy',

)) as CResult<SocketSdkSuccessResult<'getOrgSecurityPolicy'>['data']>

updatePolicy('received policy')

return result

}

updateProgress()

const results = await Promise.allSettled([

fetchScanResult().catch(e => {

updateScan('failure; unknown blocking error occurred')

return {

__proto__: null,

ok: false as const,

message: 'Socket API error',

cause:

formatErrorWithDetail('Error requesting scan', e) ||

'Error requesting scan: (no error message found)',

}

}),

fetchSecurityPolicy().catch(e => {

updatePolicy('failure; unknown blocking error occurred')

return {

__proto__: null,

ok: false as const,

message: 'Socket API error',

cause:

formatErrorWithDetail('Error requesting policy', e) ||

'Error requesting policy: (no error message found)',

}

}),

]).finally(() => {

finishedFetching = true

updateProgress()

})

const scan: CResult<SocketArtifact[]> =

results[0].status === 'fulfilled'

? results[0].value

: {

ok: false as const,

message: 'Unexpected error',

cause: 'Promise rejected unexpectedly',

}

const securityPolicy: CResult<

SocketSdkSuccessResult<'getOrgSecurityPolicy'>['data']

> =

results[1].status === 'fulfilled'

? results[1].value

: {

ok: false as const,

message: 'Unexpected error',

cause: 'Promise rejected unexpectedly',

}

if (!scan.ok) {

return scan

}

if (!securityPolicy.ok) {

return securityPolicy

}

/* c8 ignore start - defensive: scan.data is always SocketArtifact[] from the loop above */

if (!Array.isArray(scan.data)) {

return {

__proto__: null,

ok: false,

message: 'Failed to fetch',

cause: 'Was unable to fetch scan result, bailing',

}

}

/* c8 ignore stop */

return {

__proto__: null,

ok: true,

data: {

scan: scan.data satisfies SocketArtifact[],

securityPolicy: securityPolicy.data,

},

}

}