import { ParametersParameter, Identifier, Reference, Parameters, Questionnaire, FhirResource, OperationOutcome, QuestionnaireResponse, Attachment, Patient, Practitioner, Encounter } from 'fhir/r4';

interface FetchResourceRequestConfig {
    sourceServerUrl: string;
    [key: string]: any;
}
/**
 * To define a method to fetch resources from the FHIR server with a given query string
 * Method should be able to handle both absolute urls and query strings
 *
 * @param query - The query URL of the FHIR resource
 * @param requestConfig - Terminology request configs - must have sourceServerUrl + any key value pair - can be headers, auth tokens or endpoints
 * @returns A promise of the FHIR resource (or an error)!
 *
 * @example
 * const ABSOLUTE_URL_REGEX = /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/;
 *
 * export const fetchResourceCallback: FetchResourceCallback = async (
 *   query: string,
 *   requestConfig: FetchResourceRequestConfig
 * ) => {
 *   let { sourceServerUrl } = requestConfig;
 *   const { authToken } = requestConfig;
 *
 *   const headers: Record<string, string> = {
 *     Accept: 'application/json;charset=utf-8'
 *   };
 *
 *   if (authToken) {
 *     headers['Authorization'] = `Bearer ${authToken}`;
 *   }
 *
 *   if (!sourceServerUrl.endsWith('/')) {
 *     sourceServerUrl += '/';
 *   }
 *
 *   const requestUrl = ABSOLUTE_URL_REGEX.test(query) ? query : `${sourceServerUrl}${query}`;
 *   const response = await fetch(requestUrl, { headers });
 *
 *   if (!response.ok) {
 *     throw new Error(`HTTP error when performing ${requestUrl}. Status: ${response.status}`);
 *   }
 *
 *   return response.json();
 * };
 *
 *
 * @author Sean Fong
 */
interface FetchResourceCallback {
    (query: string, requestConfig: FetchResourceRequestConfig): Promise<any>;
}
interface FetchTerminologyRequestConfig {
    terminologyServerUrl: string;
    [key: string]: any;
}
/**
 * To define a method to fetch resources from the FHIR server with a given query string
 * Method should be able to handle both absolute urls and query strings
 *
 * @param query - The query URL of the FHIR resource
 * @param requestConfig - Terminology request configs - must have terminologyServerUrl + any key value pair - can be headers, auth tokens or endpoints
 * @returns A promise of the FHIR resource (or an error)!
 *
 * @example
 * const ABSOLUTE_URL_REGEX = /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/;
 *
 * export const fetchTerminologyCallback: FetchTerminologyCallback = async (
 *   query: string,
 *   requestConfig: FetchTerminologyRequestConfig
 * ) => {
 *   let { terminologyServerUrl } = requestConfig;
 *
 *   const headers: Record<string, string> = {
 *     Accept: 'application/json;charset=utf-8'
 *   };
 *
 *   if (!terminologyServerUrl.endsWith('/')) {
 *     terminologyServerUrl += '/';
 *   }
 *
 *   const requestUrl = ABSOLUTE_URL_REGEX.test(query) ? query : `${terminologyServerUrl}${query}`;
 *   const response = await fetch(requestUrl, { headers });
 *
 *   if (!response.ok) {
 *     throw new Error(`HTTP error when performing ${requestUrl}. Status: ${response.status}`);
 *   }
 *
 *   return response.json();
 * };
 *
 *
 * @author Sean Fong
 */
interface FetchTerminologyCallback {
    (query: string, requestConfig: FetchTerminologyRequestConfig): Promise<any>;
}

/**
 * Input parameters for the $populate operation
 * @see {@link http://hl7.org/fhir/uv/sdc/OperationDefinition/Questionnaire-populate}
 *
 * @author Sean Fong
 */
interface InputParameters extends Parameters {
    parameter: InputParamsArray;
}
type InputParamsArray = [
    QuestionnaireDataParameter,
    CanonicalParameter,
    SubjectParameter,
    ...ContextParameter[],
    LocalParameter
] | [QuestionnaireDataParameter, CanonicalParameter, SubjectParameter, ...ContextParameter[]] | [QuestionnaireDataParameter, SubjectParameter, ...ContextParameter[], LocalParameter] | [QuestionnaireDataParameter, SubjectParameter, ...ContextParameter[]];
type QuestionnaireDataParameter = IdentifierParameter | QuestionnaireParameter | QuestionnaireRefParameter;
interface IdentifierParameter extends ParametersParameter {
    name: 'identifier';
    valueIdentifier: Identifier;
}
interface QuestionnaireParameter extends ParametersParameter {
    name: 'questionnaire';
    resource: Questionnaire;
}
interface QuestionnaireRefParameter extends ParametersParameter {
    name: 'questionnaireRef';
    valueReference: Reference;
}
interface CanonicalParameter extends ParametersParameter {
    name: 'canonical';
    valueCanonical: string;
}
interface SubjectParameter extends ParametersParameter {
    name: 'subject';
    valueReference: Reference;
}
interface ContextParameter extends ParametersParameter {
    name: 'context';
    part: [
        {
            name: 'name';
            valueString: string;
        },
        ContextContentParameter
    ];
}
type ContextContentParameter = ReferenceContextContent | ResourceContextContent;
interface ResourceContextContent extends ParametersParameter {
    name: 'content';
    resource: FhirResource;
}
interface ReferenceContextContent extends ParametersParameter {
    name: 'content';
    valueReference: Reference;
}
interface LocalParameter extends ParametersParameter {
    name: 'local';
    valueBoolean: boolean;
}

/**
 * Output parameters for the $populate operation
 * @see {@link http://hl7.org/fhir/uv/sdc/OperationDefinition/Questionnaire-populate}
 *
 * @author Sean Fong
 */
interface OutputParameters extends Parameters {
    parameter: OutputParamArray;
}
type OutputParamArray = [ResponseParameter, IssuesParameter, CustomContextResultParameter] | [ResponseParameter, IssuesParameter] | [ResponseParameter, CustomContextResultParameter] | [ResponseParameter];
interface ResponseParameter extends ParametersParameter {
    name: 'response';
    resource: QuestionnaireResponse;
}
interface IssuesParameter extends ParametersParameter {
    name: 'issues';
    resource: OperationOutcome;
}
interface CustomContextResultParameter extends ParametersParameter {
    name: 'contextResult-custom';
    valueAttachment: Attachment;
}

/**
 * Checks if the parameters passed satisfies the conditions of populateInputParameters.
 * Returns true if both questionnaire and subject are present.
 *
 * @author Sean Fong
 */
declare function isInputParameters(parameters: Parameters): parameters is InputParameters;
/**
 * Checks if a parameter is a CanonicalParameter (has canonical value).
 */
declare function isCanonicalParameter(parameter: ParametersParameter): parameter is CanonicalParameter;
/**
 * Checks if a parameter is a SubjectParameter (has subject reference).
 */
declare function isSubjectParameter(parameter: ParametersParameter): parameter is SubjectParameter;
declare function isContextParameter(parameter: ParametersParameter): parameter is ContextParameter;
declare function isOutputParameters(parameters: Parameters): parameters is OutputParameters;

/**
 * Executes the SDC Populate Questionnaire operation - $populate.
 * Input and output specific parameters conformant to the SDC populate specification. Can be deployed as a $populate microservice.
 *
 * This function expects a nice set of populate input parameters to go. If you do you not have them, use https://github.com/aehrc/smart-forms/blob/main/packages/sdc-populate/src/inAppPopulation/utils/populateQuestionnaire.ts#L82 instead.
 * @see {@link https://hl7.org/fhir/uv/sdc/OperationDefinition-Questionnaire-populate.html}
 * Added custom output parameters populationContextResults for visual and debugging purposes.
 *
 * @author Sean Fong
 */
declare function populate(parameters: InputParameters, fetchResourceCallback: FetchResourceCallback, fetchResourceRequestConfig: FetchResourceRequestConfig, fetchTerminologyCallback?: FetchTerminologyCallback, fetchTerminologyRequestConfig?: FetchTerminologyRequestConfig): Promise<OutputParameters | OperationOutcome>;

/**
 * Represents a contextual FHIR resource reference passed during app launch.
 *
 * Used in the `fhirContext` array to describe resources relevant to the launch,
 * excluding `Patient` and `Encounter` which remain top-level parameters unless a custom role is specified.
 *
 * At least one of `reference`, `canonical`, or `identifier` must be present.
 *
 * Properties:
 * - `reference`: A relative reference to a FHIR resource (e.g. "Observation/123").
 * - `canonical`: A canonical URL referencing the resource (optionally with version).
 * - `identifier`: A FHIR `Identifier` object used to locate the resource.
 * - `type`: The resource type (e.g. "Observation"). Recommended when using `canonical` or `identifier`.
 * - `role`: URI describing the role of the context resource. If omitted, defaults to `"launch"`.
 *           Use an absolute URI unless using a predefined role from the fhirContext Role Registry.
 *
 * Notes:
 * - Multiple `fhirContext` items may reference the same resource type.
 * - When `role` is `"launch"`, it indicates the app was launched in context of that resource.
 * - `Patient` and `Encounter` are only allowed in `fhirContext` if a non-launch role is specified.
 */
interface FhirContext {
    role?: string;
    type?: string;
    canonical?: string;
    reference?: string;
    identifier?: Identifier;
    [key: string]: unknown;
}

interface PopulateResult {
    populatedResponse: QuestionnaireResponse;
    issues?: OperationOutcome;
    populatedContext?: Record<string, any>;
}
/**
 * @property questionnaire - Questionnaire to populate
 * @property fetchResourceCallback - A callback function to fetch resources from your FHIR server
 * @property fetchResourceRequestConfig - Any request configuration to be passed to the fetchResourceCallback i.e. headers, auth etc.
 * @property patient - Patient resource as patient in context
 * @property user - Practitioner resource as user in context, optional
 * @property encounter - Encounter resource as encounter in context, optional
 * @property fhirContext - An array of contextual resources within a launch. See https://build.fhir.org/ig/HL7/smart-app-launch/scopes-and-launch-context.html#fhircontext-exp
 * @property fetchTerminologyCallback - A callback function to fetch terminology resources, optional
 * @property fetchTerminologyRequestConfig - Any request configuration to be passed to the fetchTerminologyCallback i.e. headers, auth etc., optional
 * @property timeoutMs - Timeout in milliseconds for the $populate operation, default is 30000ms (30 seconds)
 *
 * @author Sean Fong
 */
interface PopulateQuestionnaireParams {
    questionnaire: Questionnaire;
    fetchResourceCallback: FetchResourceCallback;
    fetchResourceRequestConfig: FetchResourceRequestConfig;
    patient: Patient;
    user?: Practitioner;
    encounter?: Encounter;
    fhirContext?: FhirContext[];
    fetchTerminologyCallback?: FetchTerminologyCallback;
    fetchTerminologyRequestConfig?: FetchTerminologyRequestConfig;
    timeoutMs?: number;
}
/**
 * Performs an in-app population of the provided questionnaire.
 * By in-app, it means that a callback function is provided to fetch resources instead of it calling to a $populate service.
 * This function helps to you create a nice set of populate input parameters from the provided params.
 * If you already have them, use https://github.com/aehrc/smart-forms/blob/main/packages/sdc-populate/src/SDCPopulateQuestionnaireOperation/utils/populate.ts#L842 instead.
 *
 * @param params - Refer to PopulateQuestionnaireParams interface
 * @returns populateSuccess - A boolean indicating if the population was successful
 * @returns populateResult - An object containing populated response and issues if any
 *
 * @author Sean Fong
 */
declare function populateQuestionnaire(params: PopulateQuestionnaireParams): Promise<{
    populateSuccess: boolean;
    populateResult: PopulateResult | null;
}>;

export { type CustomContextResultParameter, type FetchResourceCallback, type FetchResourceRequestConfig, type FetchTerminologyCallback, type FetchTerminologyRequestConfig, type FhirContext, type IdentifierParameter, type InputParameters, type IssuesParameter, type OutputParameters, type PopulateQuestionnaireParams, type PopulateResult, type QuestionnaireRefParameter, type ResponseParameter, isCanonicalParameter, isContextParameter, isInputParameters, isOutputParameters, isSubjectParameter, populate, populateQuestionnaire };