/**

 * DNAnalyzer API Client

 * 

 * This module provides functions to interact with the DNAnalyzer API endpoints.

 * It enables the website to access the core DNAnalyzer features through a unified interface.

 * 

 * @version 1.0.0

 */

const DNAnalyzerAPI = {

    // Base URL for API requests - configurable for different environments

    baseUrl: 'http://localhost:8080/api/v1',

    /**

     * Set the base URL for the API

     * @param {string} url - The base URL for the API

     */

    setBaseUrl(url) {

        this.baseUrl = url;

    },

    /**

     * Check if the API is online

     * @returns {Promise<Object>} - API status information

     */

    async checkStatus() {

        try {

            const response = await fetch(`${this.baseUrl}/status`);

            if (!response.ok) {

                throw new Error('API status check failed');

            }

            return await response.json();

        } catch (error) {

            console.error('API status check error:', error);

            throw error;

        }

    },

    /**

     * Analyze a DNA file with various options

     * @param {File} dnaFile - The DNA file to analyze

     * @param {Object} options - Analysis options

     * @returns {Promise<Object>} - Analysis results

     */

    async analyzeDNA(dnaFile, options = {}) {

        try {

            const formData = new FormData();

            formData.append('dnaFile', dnaFile);

            // Add options to form data

            if (options.amino) formData.append('amino', options.amino);

            if (options.minCount) formData.append('minCount', options.minCount);

            if (options.maxCount) formData.append('maxCount', options.maxCount);

            if (options.reverse) formData.append('reverse', options.reverse);

            if (options.rcomplement) formData.append('rcomplement', options.rcomplement);

            if (options.codons) formData.append('codons', options.codons);

            if (options.coverage) formData.append('coverage', options.coverage);

            if (options.longest) formData.append('longest', options.longest);

            if (options.format) formData.append('format', options.format);

            const response = await fetch(`${this.baseUrl}/analyze`, {

                method: 'POST',

                body: formData

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'DNA analysis failed');

            }

            // Handle different response formats

            const contentType = response.headers.get('content-type');

            if (contentType && contentType.includes('application/json')) {

                return await response.json();

            } else {

                return await response.text();

            }

        } catch (error) {

            console.error('DNA analysis error:', error);

            throw error;

        }

    },

    /**

     * Analyze base pair composition of a DNA sequence

     * @param {string} sequence - The DNA sequence

     * @returns {Promise<Object>} - Base pair analysis results

     */

    async analyzeBasePairs(sequence) {

        try {

            const response = await fetch(`${this.baseUrl}/base-pairs`, {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify({ sequence })

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'Base pair analysis failed');

            }

            return await response.json();

        } catch (error) {

            console.error('Base pair analysis error:', error);

            throw error;

        }

    },

    /**

     * Find proteins in a DNA sequence

     * @param {string} sequence - The DNA sequence

     * @param {string} aminoAcid - The amino acid to start proteins with

     * @returns {Promise<Object>} - Protein analysis results

     */

    async findProteins(sequence, aminoAcid = 'M') {

        try {

            const response = await fetch(`${this.baseUrl}/find-proteins`, {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify({

                    sequence,

                    aminoAcid

                })

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'Protein finding failed');

            }

            return await response.json();

        } catch (error) {

            console.error('Protein finding error:', error);

            throw error;

        }

    },

    /**

     * Analyze reading frames in a DNA sequence

     * @param {string} sequence - The DNA sequence

     * @param {number} minLength - Minimum length for potential genes

     * @returns {Promise<Object>} - Reading frame analysis results

     */

    async analyzeReadingFrames(sequence, minLength = 300) {

        try {

            const response = await fetch(`${this.baseUrl}/reading-frames`, {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify({

                    sequence,

                    minLength

                })

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'Reading frame analysis failed');

            }

            return await response.json();

        } catch (error) {

            console.error('Reading frame analysis error:', error);

            throw error;

        }

    },

    /**

     * Analyze genetic testing data (23andMe, AncestryDNA, etc.)

     * @param {File} geneticFile - The genetic data file

     * @param {boolean} snpAnalysis - Whether to include detailed SNP analysis

     * @returns {Promise<Object>} - Genetic analysis results

     */

    async analyzeGeneticData(geneticFile, snpAnalysis = false) {

        try {

            const formData = new FormData();

            formData.append('geneticFile', geneticFile);

            formData.append('snpAnalysis', snpAnalysis);

            const response = await fetch(`${this.baseUrl}/analyze-genetic`, {

                method: 'POST',

                body: formData

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'Genetic data analysis failed');

            }

            return await response.json();

        } catch (error) {

            console.error('Genetic data analysis error:', error);

            throw error;

        }

    },

    /**

     * Manipulate a DNA sequence (reverse, complement)

     * @param {string} sequence - The DNA sequence

     * @param {boolean} reverse - Whether to reverse the sequence

     * @param {boolean} complement - Whether to get the complement

     * @returns {Promise<Object>} - Manipulated sequence results

     */

    async manipulateDNA(sequence, reverse = false, complement = false) {

        try {

            const response = await fetch(`${this.baseUrl}/manipulate`, {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify({

                    sequence,

                    reverse,

                    complement

                })

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'DNA manipulation failed');

            }

            return await response.json();

        } catch (error) {

            console.error('DNA manipulation error:', error);

            throw error;

        }

    },

    /**

     * Parse a DNA file (FASTA, FASTQ)

     * @param {File} file - The file to parse

     * @returns {Promise<Object>} - Parsed DNA sequence

     */

    async parseFile(file) {

        try {

            const formData = new FormData();

            formData.append('file', file);

            const response = await fetch(`${this.baseUrl}/parse`, {

                method: 'POST',

                body: formData

            });

            if (!response.ok) {

                const errorData = await response.json();

                throw new Error(errorData.message || 'File parsing failed');

            }

            return await response.json();

        } catch (error) {

            console.error('File parsing error:', error);

            throw error;

        }

    }

};

// Export the API client for use in other modules

if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {

    module.exports = DNAnalyzerAPI;

} else {

    window.DNAnalyzerAPI = DNAnalyzerAPI;

}