// fixed height
const height = 350;
// set the margins of the graph
const margin = {
        top: 10,
        right: height,
        bottom: 30,
        left: 30
    };
// get window width
const width = window.innerWidth - margin.right - margin.left -10;

// url
const currentUrl = window.location.href;


// reload page when window is resized
// (resizes every elements)
window.onresize = function(){ location.reload(); }

async function fetch_history() {
  try {
    const response = await fetch(`${currentUrl}app/datahistory`);
    const rawData = await response.json();
    var dateFormat = d3.timeParse("%a, %d %b %Y %H:%M:%S GMT");
    console.log(rawData)
    // SELECT uuid, quantity, discount_percentage, price, currency, h_timestamp
    let historyData = rawData.map(d => ({
        uuid: d[0],
        value: parseFloat(d[3].replace('$', '')),
        currency: d[4],
        date: dateFormat(d[5]),
    }));
    console.log(historyData)
    return historyData;
  } catch (error) {
    console.error('Error fetching data history: ', error);
    throw error;
  }
}

async function fetch_item() {
  try {
    // SELECT uuid, itemid, skuid, choice, attributes, image
    const response = await fetch(`${currentUrl}app/dataitem`);
    const rawData = await response.json();
    const items = rawData.reduce((item, row) => {
      const uuid = row[0];

      const itemid = row[1];
      const skuid = row[2];
      const choice = row[3];
      const attributes = row[4];
      const image = row[5];

      const values = {
        itemid: itemid,
        skuid: skuid,
        choice: choice,
        attributes: attributes,
        image: image
      };

      item[uuid] = values;

      return item;
    }, {});

    return items;
  } catch (error) {
    console.error('Error fetching data item: ', error);
    throw error;
  }
}


fetch_history().then(async function(data) {
    items = await fetch_item();

    // Date domain (width)
    const x = d3.scaleTime()
        .domain(d3.extent(data, d => d.date))
        .range([3, width-3]);

    // Group the data by (uuid)
    const nestedData = d3.group(data, d => d.uuid);
    // Create a div for each graph
    const graphDivs = d3.select("#graphs")
        .selectAll(".graph-container")
        .data(nestedData.keys())
        .enter().append("div")
        .attr("class", "graph-container");

    // Append SVG elements to each div
    const svgs = graphDivs.append("svg")
        .attr("width", width + margin.left + margin.right)
        .attr("height", height + margin.top + margin.bottom)
        .append("g")
        .attr('viewBox', `0 0 ${width} ${height}`)
        .attr("transform", `translate(${margin.left},${margin.top})`);

    var dict_xAxis = {};
    var dict_scatter = {};

    // plot for each graph
    svgs.each(function(key) {
        const dataSubset = nestedData.get(key);
        const svg = d3.select(this);

        // context on right side
        const link = `https://fr.aliexpress.com/item/${items[key].itemid}.html`;
        // image
        svg.append("image")
            .attr("x", width + margin.right*0.1)
            .attr("y", height*0.1)
            .attr("width", height*0.8)
            .attr("height", height*0.8)
            .attr("xlink:href", items[key].image)
            .on("click", function() {
                window.open(link, '_blank', 'noopener,noreferrer');
            });

        // Price domain (height)
        const y = d3.scaleLinear()
            .domain([d3.min(dataSubset, d => d.value) - 1, d3.max(dataSubset, d => d.value) + 1])
            .range([height, 0]);

        // height axis
        dict_xAxis[key] = svg.append("g")
            .attr("transform", `translate(0, ${height})`)
            .call(d3.axisBottom(x));

        // width axis
        svg.append("g")
            .call(d3.axisLeft(y));


        // clipPath, area drawn
        const clip_line = svg.append("defs").append("svg:clipPath")
            .attr("id", "clip_line")
            .append("svg:rect")
            .attr("width", width )
            .attr("height", height )
            .attr("x", 0)
            .attr("y", 0);
        const clip_dot = svg.append("defs").append("svg:clipPath")
            .attr("id", "clip_dot")
            .append("svg:rect")
            .attr("width", width+10 )
            .attr("height", height )
            .attr("x", -5)
            .attr("y", 0);

        // lines between dots
        // plotted before dots to stay below them
        svg.append("path")
            .datum(dataSubset)
            .attr("id", "line_path")
            .attr("clip-path", "url(#clip_line)") // bind to clipPath
            .attr("fill", "none")
            .attr("stroke", "black")
            .attr("stroke-width", 1.5)
            .attr("d", d3.line()
                .x(d => x(d.date))
                .y(d => y(d.value))
            );

        // brushing
        const brush = d3.brushX()
            .extent( [ [0,0], [width,height] ] )  // select whole graph
            .on("end", updateChart)               // update graph on brush release

        // line, area brushed
        const line = svg.append('g')
                        .attr("clip-path", "url(#clip_line)")

        // Add brushing
        line.append("g")
            .attr("class", "brush")
            .call(brush);

        let idleTimeout
        function idled() { idleTimeout = null; }

        // update graph on zoom brush release
        function updateChart(event,d) {
            extent = event.selection
            if(!extent){
                if (!idleTimeout) return idleTimeout = setTimeout(idled, 350);
            }else{
                x.domain([ x.invert(extent[0]), x.invert(extent[1]) ]) // new domain is brushing area
                line.select(".brush").call(brush.move, null) // remove brushing area
            }
            // Update axis
            dict_xAxis[key].transition().duration(1000).call(d3.axisBottom(x))
            // Update lines
            svg.selectAll("#line_path")
                .transition()
                .duration(1000)
                .attr("d", d3.line()
                    .x(d => x(d.date))
                    .y(d => y(d.value))
                );
            // Update dots
            svg.selectAll("circle")
                .data(dataSubset)
                .transition()
                .duration(1000)
                .attr("cx", d => x(d.date))
        }

        // reset zoom on double click
        svg.on("dblclick",function(){
            x.domain(d3.extent(data, function(d) { return d.date; }))
            // Axis
            dict_xAxis[key].transition().call(d3.axisBottom(x))
            // Lines
            svg.selectAll("#line_path")
                .transition()
                .duration(1000)
                .attr("d", d3.line()
                    .x(d => x(d.date))
                    .y(d => y(d.value))
                );
            // Dots
            svg.selectAll("circle")
                .data(dataSubset)
                .transition()
                .duration(1000)
                .attr("cx", d => x(d.date))
        });

        // TOOLTIP
        // tooltip: box with node value
        const Tooltip = d3.select(this.parentNode.parentNode).append("div")
            .style("opacity", 0)
            .attr("class", "tooltip")
            .style("background-color", "white")
            .style("border", "solid")
            .style("border-width", "2px")
            .style("border-radius", "5px")
            .style("padding", "5px")
            .style("position", "absolute");

        // Interaction functions
        const mouseover = function(event, d) {
            var formatted_date = d.date.toISOString().split('T')[0]
            Tooltip
                .style("opacity", 1)
                .html(formatted_date + "<br />" + d.value + " " + d.currency)
                .style("left", (event.pageX + 10) + "px")
                .style("top", (event.pageY + 10) + "px");
        };

        const mousemove = function(event) {
            Tooltip
                .style("left", (event.pageX + 10) + "px")
                .style("top", (event.pageY + 10) + "px");
        };

        const mouseleave = function() {
            Tooltip.style("opacity", 0)
                .style("left", 0 + "px")
                .style("top", 0 + "px"); // send tooltip outside of brushing area
        };

        // points plot
        dict_scatter[key] = svg.append("g")
                                .selectAll("circle")
                                .data(dataSubset)
                                .enter()
                                .append("circle")
                                .attr("clip-path", "url(#clip_dot)") // bind to clipPath
                                .attr("cx", d => x(d.date))
                                .attr("cy", d => y(d.value))
                                .attr("r", 5)
                                .attr("stroke", "#69b3a2")
                                .attr("stroke-width", 3)
                                .attr("fill", "white")
                                .on("mouseover", mouseover)
                                .on("mousemove", mousemove)
                                .on("mouseleave", mouseleave);
    });

})


// add item
document.getElementById("addbutton").addEventListener("click", addItem);

async function addItem() {

    const apiUrl = `${currentUrl}app/add`;

    const postData = {
        itemid: document.getElementById("additemid").value,
        attributes: document.getElementById("addattributes").value
    };

    const requestOptions = {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(postData)
    };

    const response = await fetch(apiUrl, requestOptions)
            .catch(error => {
            console.error('Error during POST request:', error);
            });


    if (response.ok) {
        console.log(response);
    } else {
        throw new Error('Error in server response');
    }

}