use crate::ast::domains::MSetAttr;

use crate::ast::pretty::pretty_vec;

use crate::ast::{

    AbstractLiteral, Domain, DomainOpError, FuncAttr, HasDomain, Literal, Moo, RecordEntry,

    SetAttr, Typeable,

    domains::{domain::Int, range::Range},

};

use crate::range;

use crate::utils::count_combinations;

use conjure_cp_core::ast::{Name, ReturnType};

use itertools::{Itertools, izip};

use num_traits::ToPrimitive;

use polyquine::Quine;

use serde::{Deserialize, Serialize};

use std::collections::BTreeSet;

use std::fmt::{Display, Formatter};

use std::iter::zip;

use uniplate::Uniplate;

#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Uniplate, Quine)]

#[path_prefix(conjure_cp::ast)]

pub struct RecordEntryGround {

    pub name: Name,

    pub domain: Moo<GroundDomain>,

}

impl From<RecordEntryGround> for RecordEntry {

}

impl TryFrom<RecordEntry> for RecordEntryGround {

    type Error = DomainOpError;

        }

}

#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Quine, Uniplate)]

#[path_prefix(conjure_cp::ast)]

pub enum GroundDomain {

    /// An empty domain of a given type

    Empty(ReturnType),

    /// A boolean value (true / false)

    Bool,

    /// An integer value in the given ranges (e.g. int(1, 3..5))

    Int(Vec<Range<Int>>),

    /// A set of elements drawn from the inner domain

    Set(SetAttr<Int>, Moo<GroundDomain>),

    /// A multiset of elements drawn from the inner domain

    MSet(MSetAttr<Int>, Moo<GroundDomain>),

    /// An N-dimensional matrix of elements drawn from the inner domain,

    /// and indices from the n index domains

    Matrix(Moo<GroundDomain>, Vec<Moo<GroundDomain>>),

    /// A tuple of N elements, each with its own domain

    Tuple(Vec<Moo<GroundDomain>>),

    /// A record

    Record(Vec<RecordEntryGround>),

    /// A function with a domain and range

    Function(FuncAttr, Moo<GroundDomain>, Moo<GroundDomain>),

}

impl GroundDomain {

                } else {

                }

            }

            }

            )),

            (GroundDomain::Set(_, _), _) | (_, GroundDomain::Set(_, _)) => {

            }

            )),

                Ok(GroundDomain::Matrix(

                ))

            }

            (GroundDomain::Matrix(_, _), _) | (_, GroundDomain::Matrix(_, _)) => {

            }

                }

            }

            (GroundDomain::Tuple(_), _) | (_, GroundDomain::Tuple(_)) => {

            }

            // TODO: Eventually we may define semantics for joining record domains. This day is not today.

            #[allow(unreachable_patterns)]

            // Technically redundant but logically clearer to have both

            (GroundDomain::Record(_), _) | (_, GroundDomain::Record(_)) => {

            }

            #[allow(unreachable_patterns)]

            // Technically redundant but logically clearer to have both

            (GroundDomain::Function(_, _, _), _) | (_, GroundDomain::Function(_, _, _)) => {

            }

        }

    /// Calculates the intersection of two domains.

    ///

    /// # Errors

    ///

    ///  - [`DomainOpError::Unbounded`] if either of the input domains are unbounded.

    ///  - [`DomainOpError::WrongType`] if the input domains are different types, or are not integer or set domains.

        // TODO: does not consider unbounded domains yet

        // needs to be tested once comprehension rules are written

            // one or more arguments is an empty int domain

            }

            // one or more arguments is an empty set(int) domain

                    GroundDomain::Int(_) | GroundDomain::Empty(ReturnType::Int)

            {

            }

                        GroundDomain::Int(_) | GroundDomain::Empty(ReturnType::Int)

            {

            }

            (

            }

            // both arguments are non-empy

            )),

            (GroundDomain::Int(_), GroundDomain::Int(_)) => {

                }

            }

        }

                ))

            }

        }

    /// Gets the length of this domain.

    ///

    /// # Errors

    ///

    /// - [`DomainOpError::Unbounded`] if the input domain is of infinite size.

                    }

                }

            }

                };

                }

            }

                };

                    // need  "multichoose", ((n  k)) == (n+k-1  k)

                    // Where n=inner_len and k=sz

                }

            }

                }

            }

                // A record is just a named tuple

                }

            }

            }

            GroundDomain::Function(_, _, _) => {

            }

        }

        // not adding a generic wildcard condition for all domains, so that this gives a compile

        // error when a domain is added.

            // empty domain can't contain anything

            },

                    // unconstrained int domain - contains all integers

                }

            },

                    // check if the literal's size is allowed by the set attribute

                    }

                }

            },

                    // check if the literal's size is allowed by the mset attribute

                    }

                }

            },

                        // Matrix literals are represented as nested 1d matrices, so the elements of

                        // the matrix literal will be the inner dimensions of the matrix.

                        {

                            // Base case - we have a 1D row. Now check if all elements in the

                            // literal are in this row's element domain.

                        } else {

                            // Otherwise, go down a dimension (e.g. 2D matrix inside a 3D tensor)

                        };

                        }

                    }

                }

            }

                        // for every element in the tuple literal, check if it is in the corresponding domain

                        }

                    }

                }

            }

                        {

                    }

                }

            },

                    }

                }

            },

        }

    /// Returns a list of all possible values in an integer domain.

    ///

    /// # Errors

    ///

    /// - [`DomainOpError::NotInteger`] if the domain is not an integer domain.

    /// - [`DomainOpError::Unbounded`] if the domain is unbounded.

        };

                Range::UnboundedR(_) | Range::UnboundedL(_) | Range::Unbounded => {

                }

            }

        }

    /// Creates an [`Domain::Int`] containing the given integers.

    ///

    /// # Examples

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain, Range};

    /// use conjure_cp_core::{domain_int_ground,range};

    /// use std::collections::BTreeSet;

    ///

    /// let elements = BTreeSet::from([1,2,3,4,5]);

    ///

    /// let domain = GroundDomain::from_set_i32(&elements);

    ///

    /// assert_eq!(domain,domain_int_ground!(1..5));

    /// ```

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain,Range};

    /// use conjure_cp_core::{domain_int_ground,range};

    /// use std::collections::BTreeSet;

    ///

    /// let elements = BTreeSet::from([1,2,4,5,7,8,9,10]);

    ///

    /// let domain = GroundDomain::from_set_i32(&elements);

    ///

    /// assert_eq!(domain,domain_int_ground!(1..2,4..5,7..10));

    /// ```

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain,Range,ReturnType};

    /// use std::collections::BTreeSet;

    ///

    /// let elements = BTreeSet::from([]);

    ///

    /// let domain = GroundDomain::from_set_i32(&elements);

    ///

    /// assert!(matches!(domain,GroundDomain::Empty(ReturnType::Int)))

    /// ```

        // Loop over the elements in ascending order, turning all sequential runs of

        // numbers into ranges.

        // the bounds of the current run of numbers.

            // As elements is a BTreeSet, current is always strictly larger than lower.

                // current is part of the current run - we now have the run lower..current

                //

                // the run lower..upper has ended.

                //

                // Add the run lower..upper to the domain, and start a new run.

            }

        }

        // add the final run to the domain

    /// Returns the domain that is the result of applying a binary operation to two integer domains.

    ///

    /// The given operator may return `None` if the operation is not defined for its arguments.

    /// Undefined values will not be included in the resulting domain.

    ///

    /// # Errors

    ///

    /// - [`DomainOpError::Unbounded`] if either of the input domains are unbounded.

    /// - [`DomainOpError::NotInteger`] if either of the input domains are not integers.

        }

    /// Returns true if the domain is finite.

                        Range::UnboundedL(_) | Range::UnboundedR(_) | Range::Unbounded

                    )

        }

    /// For a vector of literals, creates a domain that contains all the elements.

    ///

    /// The literals must all be of the same type.

    ///

    /// For abstract literals, this method merges the element domains of the literals, but not the

    /// index domains. Thus, for fixed-sized abstract literals (matrices, tuples, records, etc.),

    /// all literals in the vector must also have the same size / index domain:

    ///

    /// + Matrices: all literals must have the same index domain.

    /// + Tuples: all literals must have the same number of elements.

    /// + Records: all literals must have the same fields.

    ///

    /// # Errors

    ///

    /// - [DomainOpError::WrongType] if the input literals are of a different type to

    ///   each-other, as described above.

    ///

    /// # Examples

    ///

    /// ```

    /// use conjure_cp_core::ast::{Range, Literal, ReturnType, GroundDomain};

    ///

    /// let domain = GroundDomain::from_literal_vec(&vec![]);

    /// assert_eq!(domain,Ok(GroundDomain::Empty(ReturnType::Unknown)));

    /// ```

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral};

    /// use conjure_cp_core::{domain_int_ground, range, matrix};

    ///

    /// // `[1,2;int(2..3)], [4,5; int(2..3)]` has domain

    /// // `matrix indexed by [int(2..3)] of int(1..2,4..5)`

    ///

    /// let matrix_1 = Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(2..3)]);

    /// let matrix_2 = Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(2..3)]);

    ///

    /// let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

    ///

    /// let expected_domain = Ok(GroundDomain::Matrix(

    ///     domain_int_ground!(1..2,4..5),vec![domain_int_ground!(2..3)]));

    ///

    /// assert_eq!(domain,expected_domain);

    /// ```

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral,DomainOpError};

    /// use conjure_cp_core::{domain_int_ground, range, matrix};

    ///

    /// // `[1,2;int(2..3)], [4,5; int(1..2)]` cannot be combined

    /// // `matrix indexed by [int(2..3)] of int(1..2,4..5)`

    ///

    /// let matrix_1 = Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(2..3)]);

    /// let matrix_2 = Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(1..2)]);

    ///

    /// let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

    ///

    /// assert_eq!(domain,Err(DomainOpError::WrongType));

    /// ```

    ///

    /// ```

    /// use conjure_cp_core::ast::{GroundDomain,Range,Literal, AbstractLiteral};

    /// use conjure_cp_core::{domain_int_ground,range, matrix};

    ///

    /// // `[[1,2; int(1..2)];int(2)], [[4,5; int(1..2)]; int(2)]` has domain

    /// // `matrix indexed by [int(2),int(1..2)] of int(1..2,4..5)`

    ///

    ///

    /// let matrix_1 = Literal::AbstractLiteral(matrix![Literal::AbstractLiteral(matrix![Literal::Int(1),Literal::Int(2);domain_int_ground!(1..2)]); domain_int_ground!(2)]);

    /// let matrix_2 = Literal::AbstractLiteral(matrix![Literal::AbstractLiteral(matrix![Literal::Int(4),Literal::Int(5);domain_int_ground!(1..2)]); domain_int_ground!(2)]);

    ///

    /// let domain = GroundDomain::from_literal_vec(&vec![matrix_1,matrix_2]);

    ///

    /// let expected_domain = Ok(GroundDomain::Matrix(

    ///     domain_int_ground!(1..2,4..5),

    ///     vec![domain_int_ground!(2),domain_int_ground!(1..2)]));

    ///

    /// assert_eq!(domain,expected_domain);

    /// ```

    ///

    ///

        // TODO: use proptest to test this better?

            Literal::Int(_) => {

                // check all literals are ints, then pass this to Domain::from_set_i32.

                    };

                }

            }

            Literal::Bool(_) => {

                // check all literals are bools

                } else {

                }

            }

            Literal::AbstractLiteral(AbstractLiteral::Set(_)) => {

                    };

                }

            }

            Literal::AbstractLiteral(AbstractLiteral::MSet(_)) => {

                    };

                }

            }

                // flatten index domains of n-d matrix into list

                        "n-dimensional matrix literals should be represented as a matrix inside a matrix"

                    );

                }

                // check types and index domains

                    };

                            "n-dimensional matrix literals should be represented as a matrix inside a matrix"

                        );

                    }

                }

                // extract all the terminal elements (those that are not nested matrix literals) from the matrix literal.

                }

            }

                // for each field, calculate the element domain and add it to this list

                        };

                    }

                }

            }

                // for each field, calculate the element domain and add it to this list

                        };

                    }

                }

                Ok(GroundDomain::Record(

                ))

            }

                // Check that all items have the same domains

                }

            }

        }

        }

}

impl Typeable for GroundDomain {

            }

            }

            }

        }

}

impl Display for GroundDomain {

                } else {

                }

            }

                    "matrix indexed by [{}] of {value_domain}",

                )

            }

                    "tuple of ({})",

                )

            }

                    "record of ({})",

                    )

                )

            }

            }

        }

}