import { MeshTransmissionMaterial } from "@react-three/drei"
import { useLoader } from "@react-three/fiber"
import { useEffect, useMemo } from "react"
import * as THREE from 'three'
import { LinearEncoding, TextureLoader } from "three"

export function Copper(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Copper_${type}.webp`
    const [
        colorMap,
        normalMap,
        roughnessMap,
        metalnessMap,
        aoMap
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Roughness"),
        name("Metalness"),
        name("Ao")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            roughnessMap,
            metalnessMap,
            aoMap
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        roughnessMap,
        metalnessMap,
        aoMap]
    )

    const copper = useMemo( () => {
        const copper =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ ( 0.15, 0.15 ) }
                roughnessMap={ roughnessMap }
                roughness={ 0.637 }
                metalnessMap={ metalnessMap }
                metalness={ 1 }
                ior={ 2.3 }
                aoMap={ aoMap }
            />
        )    
        return copper
    } , [colorMap,
        normalMap,
        roughnessMap,
        metalnessMap,
        aoMap] )


    return <>
            { copper }
        </>
}

export function GlossyCeramic(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/GlossyCeramic_${type}.webp`
    const [
        colorMap,
        normalMap,
        roughnessMap
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            roughnessMap
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        roughnessMap]
    )

    const glossyCeramic = useMemo( () => {
        const glossyCeramic =(
            < meshPhysicalMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ ( 1, 1 ) }
                roughnessMap={ roughnessMap }
                roughness={ 5 }
                metalness={ 0 }
                clearcoat={ 0.5 }
                clearcoatRoughness={ 0.8 }
            />
        )    
        return glossyCeramic
    } , [colorMap,
        normalMap,
        roughnessMap] )


    return <>
            { glossyCeramic }
        </>
}

export function MatteCeramic(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/MatteCeramic_${type}.webp`
    const [
        colorMap,
        normalMap,
        roughnessMap,
        aoMap
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Roughness"),
        name("Ao")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            roughnessMap,
            aoMap
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        roughnessMap,
        aoMap]
    )

    const matteCeramic = useMemo( () => {
        const matteCeramic =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ ( 0.5, 0.5 ) }
                roughnessMap={ roughnessMap }
                roughness={ 1 }
                metalness={ 0 }
                aoMap={ aoMap }
            />
        )    
        return matteCeramic
    } , [colorMap,
        normalMap,
        roughnessMap,
        aoMap] )


    return <>
            { matteCeramic }
        </>
}

export function MattePlastic(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/MattePlastic_${type}.webp`
    const [
        colorMap,
        normalMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            roughnessMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        roughnessMap
        ]
    )

    const mattePlastic = useMemo( () => {
        const mattePlastic =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ ( .1, .1 ) }
                roughnessMap={ roughnessMap }
                roughness={ 3 }
                metalness={ 0 }
                color={ 0x464646 }
            />
        )    
        return mattePlastic
    } , [colorMap,
        normalMap,
        roughnessMap
        ] )


    return <>
            { mattePlastic }
        </>
}

export function GlossyPlastic(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/GlossyPlastic_${type}.webp`
    const [
        colorMap,
        normalMap,
        roughnessMap
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            roughnessMap
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        roughnessMap]
    )

    const glossyPlastic = useMemo( () => {
        const glossyPlastic =(
            < meshPhysicalMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ ( 0.1, 0.1 ) }
                roughnessMap={ roughnessMap }
                roughness={ 0.6 }
                reflectivity={ 0.2 }
                metalness={ 0 }
                color={ 0x919191 }
            />
        )    
        return glossyPlastic
    } , [colorMap,
        normalMap,
        roughnessMap] )


    return <>
            { glossyPlastic }
        </>
}

export function Aluminium(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Aluminium_${type}.webp`
    const [
        colorMap,
        metalnessMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Metalness"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            metalnessMap,
            roughnessMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })
    } , [colorMap,
        metalnessMap,
        roughnessMap
        ]
    )

    const aluminium = useMemo( () => {
        const aluminium =(
            < meshStandardMaterial 
                map={ colorMap }
                roughnessMap={ roughnessMap }
                roughness={ 3 }
                metalness={ 0 }
                metalnessMap={ metalnessMap }
            />
        )    
        return aluminium
    } , [colorMap,
        metalnessMap,
        roughnessMap
        ] )


    return <>
            { aluminium }
        </>
}

export function Chrome(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Chrome_${type}.webp`
    const [
        colorMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            roughnessMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })
    } , [colorMap,
        roughnessMap
        ]
    )

    const chrome = useMemo( () => {
        const chrome =(
            < meshStandardMaterial 
                map={ colorMap }
                roughnessMap={ roughnessMap }
                roughness={ 1 }
                metalness={ 1 }
            />
        )    
        return chrome
    } , [colorMap,
        roughnessMap
        ] )


    return <>
            { chrome }
        </>
}

export function Gold(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Gold_${type}.webp`
    const [
        colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Metalness"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            metalnessMap,
            roughnessMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        ]
    )

    const gold = useMemo( () => {
        const gold =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ .01 }
                metalnessMap={ metalnessMap }
                metalness={ 1 }
                roughnessMap={ roughnessMap }
                roughness={ 1 }
                color={ 0xC5B358 }
            />
        )    
        return gold
    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        ] )


    return <>
            { gold }
        </>
}

export function Rubber(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Rubber_${type}.webp`
    const [
        colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        displacementMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Metalness"),
        name("Roughness"),
        name("Height")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            metalnessMap,
            roughnessMap,
            displacementMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        displacementMap
        ]
    )

    const rubber = useMemo( () => {
        const rubber =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ 0.1 }
                metalnessMap={ metalnessMap }
                metalness={ 0.01 }
                roughnessMap={ roughnessMap }
                roughness={ 1 }
                displacementMap={ displacementMap }
                displacementScale={ .1 }
                color={ 0x808080 }
            />
        )    
        return rubber
    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        displacementMap
        ] )


    return <>
            { rubber }
        </>
}

export function TranslucentWhitePlastic(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/TranslucentWhitePlastic_${type}.webp`
    const [
        colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        opacityMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Metalness"),
        name("Roughness"),
        name("Opacity")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            metalnessMap,
            roughnessMap,
            opacityMap
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        opacityMap
        ]
    )

    const translucentWhitePlastic = useMemo( () => {
        const translucentWhitePlastic =(
            < MeshTransmissionMaterial 
                transmissionSampler
                samples={ 10 }
                anisotropy={ 1 }
                chromaticAberration={ 0.01 }
                backsideThickness={ .1 }
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ 0.05 }
                roughnessMap={ roughnessMap }
                roughness={ 4 }
                transmission={ .8 }
                clearcoat={ 1 }
                clearcoatRoughness={ 1 }
                side={ THREE.DoubleSide }                
                background={ 'white' }
                reflectivity={ 0.05 }
                thickness={ .4 }
            />
        )    
        return translucentWhitePlastic
    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap,
        opacityMap
        ] )


    return <>
            { translucentWhitePlastic }
        </>
}

export function Tin(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/Tin_${type}.webp`
    const [
        colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Metalness"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            metalnessMap,
            roughnessMap,
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        ]
    )

    const tin = useMemo( () => {
        const tin =(
            < meshStandardMaterial 
                map={ colorMap }
                normalMap={ normalMap }
                normalScale={ 0.05 }
                metalnessMap={ metalnessMap }
                metalness={ 1 }
                roughnessMap={ roughnessMap }
                roughness={ .8 }
                reflectivity={ 0.8 }
            />
        )    
        return tin
    } , [colorMap,
        normalMap,
        metalnessMap,
        roughnessMap
        ] )


    return <>
            { tin }
        </>
}

export function PaintedGreenMaterial(){
   
    const paintedGreenMaterial = useMemo( () => {
        const paintedGreenMaterial =(
            < meshPhysicalMaterial 
                color={ 0x005e00 }
                metalness={ .8 }
                // sheen={ .5 }
                reflectivity={ 0.7 }
                clearcoat={ 0.8 }
                clearcoatRoughness={ 0.8 }
            />
        )    
        return paintedGreenMaterial
    } , [] )

    return <>
            { paintedGreenMaterial }
        </>
}

export function PCBGreen(){
    const name = (type) => `https://static.dbldose.com/fluxTextures/PCBGreen_${type}.webp`
    const [
        colorMap,
        normalMap,
        aoMap,
        roughnessMap
        
      ] = useLoader( TextureLoader,[
        name("Color"),
        name("Normal"),
        name("Ao"),
        name("Roughness")
      ])

    useEffect( () => {
        [
            colorMap,
            normalMap,
            aoMap,
            roughnessMap,
            
        ].forEach((t)=>{
            t.repeat.set( 1.0 , 1.0 )
            t.wrapS = t.wrapT = THREE.RepeatWrapping
        })

        normalMap.encoding = LinearEncoding

    } , [colorMap,
        normalMap,
        aoMap,
        roughnessMap
        ]
    )

    const pcbGreen = useMemo( () => {
        const pcbGreen =(
            < meshStandardMaterial 
                // map={ colorMap }
                normalMap={ normalMap }
                normalScale={ 1 }
                aoMap={ aoMap }
                aoMapIntensity={ .3 }
                metalness={ 0 }
                roughnessMap={ roughnessMap }
                roughness={ 1.145 }
                reflectivity={ 0.75 }
                color={ 0x053309 }

            />
        )    
        return pcbGreen
    } , [colorMap,
        normalMap,
        aoMap,
        roughnessMap
        ] )


    return <>
            { pcbGreen }
        </>
}